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

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

@@ -14,35 +14,78 @@
 # limitations under the License.
 # ===============================================================================
 
-from daal4py.sklearn._utils import daal_check_version
 import logging
+from abc import ABC
 
-if daal_check_version((2023, 'P', 100)):
-    import numpy as np
+from daal4py.sklearn._utils import daal_check_version
+
+
+def get_coef(self):
+    return self._coef_
+
+
+def set_coef(self, value):
+    self._coef_ = value
+    if hasattr(self, "_onedal_estimator"):
+        self._onedal_estimator.coef_ = value
+        if not self._is_in_fit:
+            del self._onedal_estimator._onedal_model
+
+
+def get_intercept(self):
+    return self._intercept_
 
-    from ._common import BaseLinearRegression
-    from ..._device_offload import dispatch, wrap_output_data
 
-    from ...utils.validation import _assert_all_finite
-    from daal4py.sklearn._utils import (
-        get_dtype, make2d, sklearn_check_version, PatchingConditionsChain)
+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 BaseLinearRegression(ABC):
+    def _save_attributes(self):
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+        self.fit_status_ = 0
+        self._coef_ = self._onedal_estimator.coef_
+        self._intercept_ = self._onedal_estimator.intercept_
+        self._sparse = False
+
+        self.coef_ = property(get_coef, set_coef)
+        self.intercept_ = property(get_intercept, set_intercept)
+
+        self._is_in_fit = True
+        self.coef_ = self._coef_
+        self.intercept_ = self._intercept_
+        self._is_in_fit = False
+
+
+if daal_check_version((2023, "P", 100)):
+    import numpy as np
     from sklearn.linear_model import LinearRegression as sklearn_LinearRegression
 
-    if sklearn_check_version('1.0') and not sklearn_check_version('1.2'):
+    from daal4py.sklearn._utils import get_dtype, make2d, sklearn_check_version
+
+    from .._device_offload import dispatch, wrap_output_data
+    from .._utils import PatchingConditionsChain, get_patch_message
+    from ..utils.validation import _assert_all_finite
+
+    if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
         from sklearn.linear_model._base import _deprecate_normalize
 
-    from sklearn.utils.validation import _deprecate_positional_args, check_X_y
-    from sklearn.exceptions import NotFittedError
     from scipy.sparse import issparse
+    from sklearn.exceptions import NotFittedError
+    from sklearn.utils.validation import _deprecate_positional_args, check_X_y
 
     from onedal.linear_model import LinearRegression as onedal_LinearRegression
-    from onedal.datatypes import (_num_samples, _get_2d_shape)
+    from onedal.utils import _num_features, _num_samples
 
     class LinearRegression(sklearn_LinearRegression, BaseLinearRegression):
         __doc__ = sklearn_LinearRegression.__doc__
         intercept_, coef_ = None, None
 
-        if sklearn_check_version('1.2'):
+        if sklearn_check_version("1.2"):
             _parameter_constraints: dict = {
                 **sklearn_LinearRegression._parameter_constraints
             }
@@ -60,11 +103,13 @@ if daal_check_version((2023, 'P', 100)):
                     n_jobs=n_jobs,
                     positive=positive,
                 )
-        elif sklearn_check_version('0.24'):
+
+        elif sklearn_check_version("0.24"):
+
             def __init__(
                 self,
                 fit_intercept=True,
-                normalize='deprecated' if sklearn_check_version('1.0') else False,
+                normalize="deprecated" if sklearn_check_version("1.0") else False,
                 copy_X=True,
                 n_jobs=None,
                 positive=False,
@@ -76,7 +121,9 @@ if daal_check_version((2023, 'P', 100)):
                     n_jobs=n_jobs,
                     positive=positive,
                 )
+
         else:
+
             def __init__(
                 self,
                 fit_intercept=True,
@@ -88,7 +135,7 @@ if daal_check_version((2023, 'P', 100)):
                     fit_intercept=fit_intercept,
                     normalize=normalize,
                     copy_X=copy_X,
-                    n_jobs=n_jobs
+                    n_jobs=n_jobs,
                 )
 
         def fit(self, X, y, sample_weight=None):
@@ -109,15 +156,22 @@ if daal_check_version((2023, 'P', 100)):
             self : object
                 Fitted Estimator.
             """
-            if sklearn_check_version('1.0'):
+            if sklearn_check_version("1.0"):
                 self._check_feature_names(X, reset=True)
             if sklearn_check_version("1.2"):
                 self._validate_params()
 
-            dispatch(self, 'fit', {
-                'onedal': self.__class__._onedal_fit,
-                'sklearn': sklearn_LinearRegression.fit,
-            }, X, y, sample_weight)
+            dispatch(
+                self,
+                "fit",
+                {
+                    "onedal": self.__class__._onedal_fit,
+                    "sklearn": sklearn_LinearRegression.fit,
+                },
+                X,
+                y,
+                sample_weight,
+            )
             return self
 
         @wrap_output_data
@@ -135,16 +189,21 @@ if daal_check_version((2023, 'P', 100)):
             """
             if sklearn_check_version("1.0"):
                 self._check_feature_names(X, reset=False)
-            return dispatch(self, 'predict', {
-                'onedal': self.__class__._onedal_predict,
-                'sklearn': sklearn_LinearRegression.predict,
-            }, X)
+            return dispatch(
+                self,
+                "predict",
+                {
+                    "onedal": self.__class__._onedal_predict,
+                    "sklearn": sklearn_LinearRegression.predict,
+                },
+                X,
+            )
 
         def _test_type_and_finiteness(self, X_in):
             X = X_in if isinstance(X_in, np.ndarray) else np.asarray(X_in)
 
             dtype = X.dtype
-            if 'complex' in str(type(dtype)):
+            if "complex" in str(type(dtype)):
                 return False
 
             try:
@@ -154,77 +213,99 @@ if daal_check_version((2023, 'P', 100)):
             return True
 
         def _onedal_fit_supported(self, method_name, *data):
-            assert method_name == 'fit'
+            assert method_name == "fit"
             assert len(data) == 3
             X, y, sample_weight = data
 
             class_name = self.__class__.__name__
             patching_status = PatchingConditionsChain(
-                f'sklearn.linear_model.{class_name}.fit')
+                f"sklearn.linear_model.{class_name}.fit"
+            )
 
-            normalize_is_set = hasattr(self, 'normalize') and self.normalize \
-                and self.normalize != 'deprecated'
-            positive_is_set = hasattr(self, 'positive') and self.positive
+            normalize_is_set = (
+                hasattr(self, "normalize")
+                and self.normalize
+                and self.normalize != "deprecated"
+            )
+            positive_is_set = hasattr(self, "positive") and self.positive
+
+            n_samples = _num_samples(X)
+            n_features = _num_features(X, fallback_1d=True)
 
-            n_samples, n_features = _get_2d_shape(X, fallback_1d=True)
             # Check if equations are well defined
-            is_good_for_onedal = n_samples > \
-                (n_features + int(self.fit_intercept))
-
-            dal_ready = patching_status.and_conditions([
-                (sample_weight is None, 'Sample weight is not supported.'),
-                (not issparse(X) and not issparse(y), 'Sparse input is not supported.'),
-                (not normalize_is_set, 'Normalization is not supported.'),
-                (not positive_is_set, 'Forced positive coefficients are not supported.'),
-                (is_good_for_onedal,
-                 'The shape of X (fitting) does not satisfy oneDAL requirements:.'
-                 'Number of features + 1 >= number of samples.')
-            ])
+            is_good_for_onedal = n_samples > (n_features + int(self.fit_intercept))
+
+            dal_ready = patching_status.and_conditions(
+                [
+                    (sample_weight is None, "Sample weight is not supported."),
+                    (
+                        not issparse(X) and not issparse(y),
+                        "Sparse input is not supported.",
+                    ),
+                    (not normalize_is_set, "Normalization is not supported."),
+                    (
+                        not positive_is_set,
+                        "Forced positive coefficients are not supported.",
+                    ),
+                    (
+                        is_good_for_onedal,
+                        "The shape of X (fitting) does not satisfy oneDAL requirements:."
+                        "Number of features + 1 >= number of samples.",
+                    ),
+                ]
+            )
             if not dal_ready:
-                return patching_status.get_status(logs=True)
+                return patching_status
 
             if not patching_status.and_condition(
-                self._test_type_and_finiteness(X), 'Input X is not supported.'
+                self._test_type_and_finiteness(X), "Input X is not supported."
             ):
-                return patching_status.get_status(logs=True)
+                return patching_status
 
             patching_status.and_condition(
-                self._test_type_and_finiteness(y), 'Input y is not supported.')
+                self._test_type_and_finiteness(y), "Input y is not supported."
+            )
 
-            return patching_status.get_status(logs=True)
+            return patching_status
 
         def _onedal_predict_supported(self, method_name, *data):
-            assert method_name == 'predict'
+            assert method_name == "predict"
             assert len(data) == 1
 
             class_name = self.__class__.__name__
             patching_status = PatchingConditionsChain(
-                f'sklearn.linear_model.{class_name}.predict')
+                f"sklearn.linear_model.{class_name}.predict"
+            )
 
             n_samples = _num_samples(*data)
-            model_is_sparse = issparse(self.coef_) or \
-                (self.fit_intercept and issparse(self.intercept_))
-            dal_ready = patching_status.and_conditions([
-                (n_samples > 0, 'Number of samples is less than 1.'),
-                (not issparse(*data), 'Sparse input is not supported.'),
-                (not model_is_sparse, 'Sparse coefficients are not supported.'),
-                (hasattr(self, '_onedal_estimator'), 'oneDAL model was not trained.')
-            ])
+            model_is_sparse = issparse(self.coef_) or (
+                self.fit_intercept and issparse(self.intercept_)
+            )
+            dal_ready = patching_status.and_conditions(
+                [
+                    (n_samples > 0, "Number of samples is less than 1."),
+                    (not issparse(*data), "Sparse input is not supported."),
+                    (not model_is_sparse, "Sparse coefficients are not supported."),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained."),
+                ]
+            )
             if not dal_ready:
-                return patching_status.get_status(logs=True)
+                return patching_status
 
             patching_status.and_condition(
-                self._test_type_and_finiteness(*data), 'Input X is not supported.')
+                self._test_type_and_finiteness(*data), "Input X is not supported."
+            )
 
-            return patching_status.get_status(logs=True)
+            return patching_status
 
         def _onedal_supported(self, method_name, *data):
-            if method_name == 'fit':
+            if method_name == "fit":
                 return self._onedal_fit_supported(method_name, *data)
-            if method_name == 'predict':
+            if method_name == "predict":
                 return self._onedal_predict_supported(method_name, *data)
             raise RuntimeError(
-                f'Unknown method {method_name} in {self.__class__.__name__}')
+                f"Unknown method {method_name} in {self.__class__.__name__}"
+            )
 
         def _onedal_gpu_supported(self, method_name, *data):
             return self._onedal_supported(method_name, *data)
@@ -233,30 +314,27 @@ if daal_check_version((2023, 'P', 100)):
             return self._onedal_supported(method_name, *data)
 
         def _initialize_onedal_estimator(self):
-            onedal_params = {
-                'fit_intercept': self.fit_intercept,
-                'copy_X': self.copy_X}
+            onedal_params = {"fit_intercept": self.fit_intercept, "copy_X": self.copy_X}
             self._onedal_estimator = onedal_LinearRegression(**onedal_params)
 
         def _onedal_fit(self, X, y, sample_weight, queue=None):
             assert sample_weight is None
 
             check_params = {
-                'X': X,
-                'y': y,
-                'dtype': [np.float64, np.float32],
-                'accept_sparse': ['csr', 'csc', 'coo'],
-                'y_numeric': True,
-                'multi_output': True,
-                'force_all_finite': False
+                "X": X,
+                "y": y,
+                "dtype": [np.float64, np.float32],
+                "accept_sparse": ["csr", "csc", "coo"],
+                "y_numeric": True,
+                "multi_output": True,
+                "force_all_finite": False,
             }
-            if sklearn_check_version('1.2'):
+            if sklearn_check_version("1.2"):
                 X, y = self._validate_data(**check_params)
             else:
                 X, y = check_X_y(**check_params)
 
-            if sklearn_check_version(
-                    '1.0') and not sklearn_check_version('1.2'):
+            if sklearn_check_version("1.0") and not sklearn_check_version("1.2"):
                 self._normalize = _deprecate_normalize(
                     self.normalize,
                     default=False,
@@ -264,13 +342,22 @@ if daal_check_version((2023, 'P', 100)):
                 )
 
             self._initialize_onedal_estimator()
-            self._onedal_estimator.fit(X, y, queue=queue)
+            try:
+                self._onedal_estimator.fit(X, y, queue=queue)
+                self._save_attributes()
+
+            except RuntimeError:
+                logging.getLogger("sklearnex").info(
+                    f"{self.__class__.__name__}.fit "
+                    + get_patch_message("sklearn_after_onedal")
+                )
 
-            self._save_attributes()
+                del self._onedal_estimator
+                super().fit(X, y)
 
         def _onedal_predict(self, X, queue=None):
             X = self._validate_data(X, accept_sparse=False, reset=False)
-            if not hasattr(self, '_onedal_estimator'):
+            if not hasattr(self, "_onedal_estimator"):
                 self._initialize_onedal_estimator()
                 self._onedal_estimator.coef_ = self.coef_
                 self._onedal_estimator.intercept_ = self.intercept_
@@ -279,5 +366,8 @@ if daal_check_version((2023, 'P', 100)):
 
 else:
     from daal4py.sklearn.linear_model import LinearRegression
-    logging.warning('Preview LinearRegression requires oneDAL version >= 2023.1 '
-                    'but it was not found')
+
+    logging.warning(
+        "Sklearnex LinearRegression requires oneDAL version >= 2023.1 "
+        "but it was not found"
+    )

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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.linear_model import logistic_regression_path, LogisticRegression
+from daal4py.sklearn.linear_model import LogisticRegression, logistic_regression_path

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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.linear_model import Ridge

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/linear_model/tests/test_linear.py

@@ -16,46 +16,62 @@
 # ===============================================================================
 
 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():
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_sklearnex_import_linear(dataframe, queue):
     from sklearnex.linear_model import LinearRegression
+
     X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
     y = np.dot(X, np.array([1, 2])) + 3
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
     linreg = LinearRegression().fit(X, y)
-    assert 'daal4py' in linreg.__module__
+    if daal_check_version((2023, "P", 100)):
+        assert hasattr(linreg, "_onedal_estimator")
+    assert "sklearnex" in linreg.__module__
     assert linreg.n_features_in_ == 2
-    assert_allclose(linreg.intercept_, 3.)
-    assert_allclose(linreg.coef_, [1., 2.])
+    assert_allclose(_as_numpy(linreg.intercept_), 3.0)
+    assert_allclose(_as_numpy(linreg.coef_), [1.0, 2.0])
 
 
 def test_sklearnex_import_ridge():
     from sklearnex.linear_model import Ridge
+
     X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
     y = np.dot(X, np.array([1, 2])) + 3
     ridgereg = Ridge().fit(X, y)
-    assert 'daal4py' in ridgereg.__module__
+    assert "daal4py" in ridgereg.__module__
     assert_allclose(ridgereg.intercept_, 4.5)
     assert_allclose(ridgereg.coef_, [0.8, 1.4])
 
 
 def test_sklearnex_import_lasso():
     from sklearnex.linear_model import Lasso
+
     X = [[0, 0], [1, 1], [2, 2]]
     y = [0, 1, 2]
     lasso = Lasso(alpha=0.1).fit(X, y)
-    assert 'daal4py' in lasso.__module__
+    assert "daal4py" in lasso.__module__
     assert_allclose(lasso.intercept_, 0.15)
     assert_allclose(lasso.coef_, [0.85, 0.0])
 
 
 def test_sklearnex_import_elastic():
     from sklearnex.linear_model import ElasticNet
+
     X, y = make_regression(n_features=2, random_state=0)
     elasticnet = ElasticNet(random_state=0).fit(X, y)
-    assert 'daal4py' in elasticnet.__module__
+    assert "daal4py" in elasticnet.__module__
     assert_allclose(elasticnet.intercept_, 1.451, atol=1e-3)
     assert_allclose(elasticnet.coef_, [18.838, 64.559], atol=1e-3)

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/linear_model/tests/test_logreg.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,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.
-#===============================================================================
+# ===============================================================================
 
 import numpy as np
 from numpy.testing import assert_allclose
@@ -22,7 +22,8 @@ from sklearn.datasets import load_iris
 
 def test_sklearnex_import():
     from sklearnex.linear_model import LogisticRegression
+
     X, y = load_iris(return_X_y=True)
     logreg = LogisticRegression(random_state=0, max_iter=200).fit(X, y)
-    assert 'daal4py' in logreg.__module__
+    assert "daal4py" in logreg.__module__
     assert_allclose(logreg.score(X, y), 0.9733, atol=1e-3)

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,8 +13,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 .t_sne import TSNE
 
-__all__ = ['TSNE']
+__all__ = ["TSNE"]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/manifold/t_sne.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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.manifold import TSNE

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/manifold/tests/test_tsne.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,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.
-#===============================================================================
+# ===============================================================================
 
 import numpy as np
 from numpy.testing import assert_allclose
@@ -21,6 +21,7 @@ from numpy.testing import assert_allclose
 
 def test_sklearnex_import():
     from sklearnex.manifold import TSNE
+
     X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
     tsne = TSNE(n_components=2, perplexity=2.0).fit(X)
-    assert 'daal4py' in tsne.__module__
+    assert "daal4py" in tsne.__module__

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,12 +13,12 @@
 # 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 .ranking import roc_auc_score
 from .pairwise import pairwise_distances
+from .ranking import roc_auc_score
 
 __all__ = [
-    'roc_auc_score',
-    'pairwise_distances',
+    "roc_auc_score",
+    "pairwise_distances",
 ]

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/metrics/pairwise.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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.metrics import pairwise_distances

{scikit_learn_intelex-2023.2.1.data → scikit_learn_intelex-2024.0.1.data}/data/Lib/site-packages/sklearnex/metrics/ranking.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-#===============================================================================
+# ===============================================================================
 # Copyright 2021 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +13,6 @@
 # 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.metrics import roc_auc_score