scikit-learn-intelex 2025.0.1__py312-none-win_amd64.whl → 2025.2.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -25,7 +25,7 @@ if daal_check_version((2023, "P", 200)):
 
     import numpy as np
     from scipy.sparse import issparse
-    from sklearn.cluster import KMeans as sklearn_KMeans
+    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,
@@ -41,12 +41,17 @@ if daal_check_version((2023, "P", 200)):
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
 
-    @control_n_jobs(decorated_methods=["fit", "predict", "transform", "fit_transform"])
-    class KMeans(sklearn_KMeans):
-        __doc__ = sklearn_KMeans.__doc__
+    if sklearn_check_version("1.6"):
+        from sklearn.utils.validation import validate_data
+    else:
+        validate_data = _sklearn_KMeans._validate_data
+
+    @control_n_jobs(decorated_methods=["fit", "fit_transform", "predict", "score"])
+    class KMeans(_sklearn_KMeans):
+        __doc__ = _sklearn_KMeans.__doc__
 
         if sklearn_check_version("1.2"):
-            _parameter_constraints: dict = {**sklearn_KMeans._parameter_constraints}
+            _parameter_constraints: dict = {**_sklearn_KMeans._parameter_constraints}
 
         def __init__(
             self,
@@ -97,8 +102,8 @@ if daal_check_version((2023, "P", 200)):
             patching_status = PatchingConditionsChain(f"sklearn.cluster.{class_name}.fit")
 
             sample_count = _num_samples(X)
-            self._algorithm = self.algorithm
             supported_algs = ["auto", "full", "lloyd", "elkan"]
+
             if self.algorithm == "elkan":
                 logging.getLogger("sklearnex").info(
                     "oneDAL does not support 'elkan', using 'lloyd' algorithm instead."
@@ -117,6 +122,7 @@ if daal_check_version((2023, "P", 200)):
                         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,
@@ -140,7 +146,7 @@ if daal_check_version((2023, "P", 200)):
                 "fit",
                 {
                     "onedal": self.__class__._onedal_fit,
-                    "sklearn": sklearn_KMeans.fit,
+                    "sklearn": _sklearn_KMeans.fit,
                 },
                 X,
                 y,
@@ -150,7 +156,8 @@ if daal_check_version((2023, "P", 200)):
             return self
 
         def _onedal_fit(self, X, _, sample_weight, queue=None):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 accept_sparse="csr",
                 dtype=[np.float64, np.float32],
@@ -175,7 +182,9 @@ if daal_check_version((2023, "P", 200)):
         def _validate_sample_weight(self, sample_weight, X):
             if sample_weight is None:
                 return True
-            elif isinstance(sample_weight, numbers.Number):
+            elif isinstance(sample_weight, numbers.Number) or isinstance(
+                sample_weight, str
+            ):
                 return True
             else:
                 sample_weight = _check_sample_weight(
@@ -188,14 +197,19 @@ if daal_check_version((2023, "P", 200)):
                 else:
                     return False
 
-        def _onedal_predict_supported(self, method_name, X, sample_weight=None):
+        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)
-            patching_status = PatchingConditionsChain(
-                f"sklearn.cluster.{class_name}.predict"
-            )
 
             # algorithm "auto" has been deprecated since 1.1,
             # algorithm "full" has been replaced by "lloyd"
@@ -217,6 +231,7 @@ if daal_check_version((2023, "P", 200)):
                         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).",
@@ -235,13 +250,13 @@ if daal_check_version((2023, "P", 200)):
             @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,
+                        "sklearn": _sklearn_KMeans.predict,
                     },
                     X,
                 )
@@ -257,38 +272,37 @@ if daal_check_version((2023, "P", 200)):
                 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,
+                        "sklearn": _sklearn_KMeans.predict,
                     },
                     X,
-                    sample_weight=sample_weight,
+                    sample_weight,
                 )
 
         def _onedal_predict(self, X, sample_weight=None, queue=None):
-            check_is_fitted(self)
-
-            X = self._validate_data(
+            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_
@@ -320,22 +334,22 @@ if daal_check_version((2023, "P", 200)):
 
         @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,
+                    "sklearn": _sklearn_KMeans.score,
                 },
                 X,
                 y,
-                sample_weight=sample_weight,
+                sample_weight,
             )
 
-        def _onedal_score(self, X, y, sample_weight=None, queue=None):
-            check_is_fitted(self)
-
-            X = self._validate_data(
+        def _onedal_score(self, X, y=None, sample_weight=None, queue=None):
+            X = validate_data(
+                self,
                 X,
                 accept_sparse="csr",
                 reset=False,
@@ -369,11 +383,11 @@ if daal_check_version((2023, "P", 200)):
 
             self._n_init = self._onedal_estimator._n_init
 
-        fit.__doc__ = sklearn_KMeans.fit.__doc__
-        predict.__doc__ = sklearn_KMeans.predict.__doc__
-        transform.__doc__ = sklearn_KMeans.transform.__doc__
-        fit_transform.__doc__ = sklearn_KMeans.fit_transform.__doc__
-        score.__doc__ = sklearn_KMeans.score.__doc__
+        fit.__doc__ = _sklearn_KMeans.fit.__doc__
+        predict.__doc__ = _sklearn_KMeans.predict.__doc__
+        transform.__doc__ = _sklearn_KMeans.transform.__doc__
+        fit_transform.__doc__ = _sklearn_KMeans.fit_transform.__doc__
+        score.__doc__ = _sklearn_KMeans.score.__doc__
 
 else:
     from daal4py.sklearn.cluster import KMeans

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/cluster/tests/test_kmeans.py

@@ -28,6 +28,7 @@ from onedal.tests.utils._dataframes_support import (
     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):
@@ -45,11 +46,11 @@ def generate_dense_dataset(n_samples, n_features, density, n_clusters):
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@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):
-    if not sklearn_check_version("1.1") and algorithm == "lloyd":
-        pytest.skip("lloyd requires sklearn>=1.1.")
     from sklearnex.cluster import KMeans
 
     X_dense = generate_dense_dataset(1000, 10, 0.5, 3)
@@ -70,7 +71,9 @@ def test_sklearnex_import_for_dense_data(dataframe, queue, algorithm, init):
     reason="Sparse data requires oneDAL>=2024.7.0",
 )
 @pytest.mark.parametrize("queue", get_queues())
-@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@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
@@ -86,11 +89,10 @@ def test_sklearnex_import_for_sparse_data(queue, algorithm, init):
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
-@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@pytest.mark.parametrize(
+    "algorithm", ["lloyd" if sklearn_check_version("1.1") else "full", "elkan"]
+)
 def test_results_on_dense_gold_data(dataframe, queue, algorithm):
-    if not sklearn_check_version("1.1") and algorithm == "lloyd":
-        pytest.skip("lloyd requires sklearn>=1.1.")
-
     from sklearnex.cluster import KMeans
 
     X_train = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
@@ -121,15 +123,17 @@ def test_results_on_dense_gold_data(dataframe, queue, algorithm):
 )
 @pytest.mark.parametrize("queue", get_queues())
 @pytest.mark.parametrize("init", ["k-means++", "random", "arraylike"])
-@pytest.mark.parametrize("algorithm", ["lloyd", "elkan"])
+@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":
-        pytest.skip("Random initialization in sparse K-means is buggy.")
+    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

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/conftest.py

@@ -27,6 +27,9 @@ 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)
@@ -71,3 +74,9 @@ def with_array_api():
             yield
     else:
         yield
+
+
+@pytest.fixture
+def without_allow_sklearn_after_onedal():
+    with config_context(allow_sklearn_after_onedal=False):
+        yield

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -20,10 +20,10 @@ import warnings
 import numpy as np
 from scipy import linalg
 from sklearn.base import BaseEstimator, clone
-from sklearn.covariance import EmpiricalCovariance as sklearn_EmpiricalCovariance
+from sklearn.covariance import EmpiricalCovariance as _sklearn_EmpiricalCovariance
 from sklearn.covariance import log_likelihood
 from sklearn.utils import check_array, gen_batches
-from sklearn.utils.validation import _num_features
+from sklearn.utils.validation import _num_features, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
@@ -33,16 +33,21 @@ from onedal.covariance import (
 from sklearnex import config_context
 
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import PatchingConditionsChain, register_hyperparameters
+from .._utils import IntelEstimator, PatchingConditionsChain, register_hyperparameters
 from ..metrics import pairwise_distances
 from ..utils._array_api import get_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
-class IncrementalEmpiricalCovariance(BaseEstimator):
+class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
     """
     Maximum likelihood covariance estimator that allows for the estimation when the data are split into
     batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
@@ -87,6 +92,13 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Note
+    ----
+    Serializing instances of this class will trigger a forced finalization of calculations.
+    Since finalize_fit can't be dispatched without directly provided queue
+    and the dispatching policy can't be serialized, the computation is finalized
+    during serialization and the policy is not saved in serialized data.
+
     Examples
     --------
     >>> import numpy as np
@@ -116,8 +128,8 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             "copy": ["boolean"],
         }
 
-    get_precision = sklearn_EmpiricalCovariance.get_precision
-    error_norm = wrap_output_data(sklearn_EmpiricalCovariance.error_norm)
+    get_precision = _sklearn_EmpiricalCovariance.get_precision
+    error_norm = wrap_output_data(_sklearn_EmpiricalCovariance.error_norm)
 
     def __init__(
         self, *, store_precision=False, assume_centered=False, batch_size=None, copy=True
@@ -181,7 +193,8 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
                 self._validate_params()
 
             if sklearn_check_version("1.0"):
-                X = self._validate_data(
+                X = validate_data(
+                    self,
                     X,
                     dtype=[np.float64, np.float32],
                     reset=first_pass,
@@ -220,9 +233,11 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
     def score(self, X_test, y=None):
         xp, _ = get_namespace(X_test)
 
+        check_is_fitted(self)
         location = self.location_
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X_test,
                 dtype=[np.float64, np.float32],
                 reset=False,
@@ -324,8 +339,12 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
 
         # finite check occurs on onedal side
         if sklearn_check_version("1.0"):
-            X = self._validate_data(
-                X, dtype=[np.float64, np.float32], copy=self.copy, force_all_finite=False
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                copy=self.copy,
+                force_all_finite=False,
             )
         else:
             X = check_array(
@@ -381,6 +400,6 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
     _onedal_cpu_supported = _onedal_supported
     _onedal_gpu_supported = _onedal_supported
 
-    mahalanobis.__doc__ = sklearn_EmpiricalCovariance.mahalanobis.__doc__
-    error_norm.__doc__ = sklearn_EmpiricalCovariance.error_norm.__doc__
-    score.__doc__ = sklearn_EmpiricalCovariance.score.__doc__
+    mahalanobis.__doc__ = _sklearn_EmpiricalCovariance.mahalanobis.__doc__
+    error_norm.__doc__ = _sklearn_EmpiricalCovariance.error_norm.__doc__
+    score.__doc__ = _sklearn_EmpiricalCovariance.score.__doc__

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/covariance/tests/test_incremental_covariance.py

@@ -14,6 +14,17 @@
 # limitations under the License.
 # ===============================================================================
 
+from os import environ
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+# sklearn requires manual enabling of Scipy array API support
+# if `array-api-compat` package is present in environment
+# TODO: create generic approach to handle this for all tests
+if sklearn_check_version("1.6"):
+    environ["SCIPY_ARRAY_API"] = "1"
+
+
 import numpy as np
 import pytest
 from numpy.linalg import slogdet
@@ -209,6 +220,56 @@ def test_whitened_toy_score(dataframe, queue):
     assert_allclose(expected_result, result, atol=1e-6)
 
 
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_sklearnex_incremental_estimatior_pickle(dataframe, queue, dtype):
+    import pickle
+
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+
+    inccov = IncrementalEmpiricalCovariance()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    X_split_df = _convert_to_dataframe(X_split[0], sycl_queue=queue, target_df=dataframe)
+    inccov.partial_fit(X_split_df)
+    inccov_loaded.partial_fit(X_split_df)
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov.batch_size == inccov_loaded.batch_size
+    assert inccov.n_features_in_ == inccov_loaded.n_features_in_
+    assert inccov.n_samples_seen_ == inccov_loaded.n_samples_seen_
+    if hasattr(inccov, "_parameter_constraints"):
+        assert inccov._parameter_constraints == inccov_loaded._parameter_constraints
+    assert inccov.n_jobs == inccov_loaded.n_jobs
+
+    X_split_df = _convert_to_dataframe(X_split[1], sycl_queue=queue, target_df=dataframe)
+    inccov.partial_fit(X_split_df)
+    inccov_loaded.partial_fit(X_split_df)
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+
+    assert_allclose(inccov.location_, inccov_loaded.location_, atol=1e-6)
+    assert_allclose(inccov.covariance_, inccov_loaded.covariance_, atol=1e-6)
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert_allclose(inccov.location_, inccov_loaded.location_, atol=1e-6)
+    assert_allclose(inccov.covariance_, inccov_loaded.covariance_, atol=1e-6)
+
+
 # Monkeypatch IncrementalEmpiricalCovariance into relevant sklearn.covariance tests
 @pytest.mark.allow_sklearn_fallback
 @pytest.mark.parametrize(

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -25,7 +25,7 @@ if daal_check_version((2024, "P", 100)):
 
     import numpy as np
     from scipy.sparse import issparse
-    from sklearn.utils.validation import check_is_fitted
+    from sklearn.utils.validation import check_array, check_is_fitted
 
     from daal4py.sklearn._n_jobs_support import control_n_jobs
     from daal4py.sklearn._utils import sklearn_check_version
@@ -40,16 +40,21 @@ if daal_check_version((2024, "P", 100)):
     if sklearn_check_version("1.2"):
         from sklearn.utils._param_validation import StrOptions
 
-    from sklearn.decomposition import PCA as sklearn_PCA
+    from sklearn.decomposition import PCA as _sklearn_PCA
 
     from onedal.decomposition import PCA as onedal_PCA
 
+    if sklearn_check_version("1.6"):
+        from sklearn.utils.validation import validate_data
+    else:
+        validate_data = _sklearn_PCA._validate_data
+
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
-    class PCA(sklearn_PCA):
-        __doc__ = sklearn_PCA.__doc__
+    class PCA(_sklearn_PCA):
+        __doc__ = _sklearn_PCA.__doc__
 
         if sklearn_check_version("1.2"):
-            _parameter_constraints: dict = {**sklearn_PCA._parameter_constraints}
+            _parameter_constraints: dict = {**_sklearn_PCA._parameter_constraints}
             # "onedal_svd" solver uses oneDAL's PCA-SVD algorithm
             # and required for testing purposes to fully enable it in future.
             # "covariance_eigh" solver is added for ability to explicitly request
@@ -127,13 +132,14 @@ if daal_check_version((2024, "P", 100)):
                 "fit",
                 {
                     "onedal": self.__class__._onedal_fit,
-                    "sklearn": sklearn_PCA._fit,
+                    "sklearn": _sklearn_PCA._fit,
                 },
                 X,
             )
 
         def _onedal_fit(self, X, queue=None):
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[np.float64, np.float32],
                 ensure_2d=True,
@@ -164,25 +170,30 @@ if daal_check_version((2024, "P", 100)):
 
         @wrap_output_data
         def transform(self, X):
+            check_is_fitted(self)
             return dispatch(
                 self,
                 "transform",
                 {
                     "onedal": self.__class__._onedal_transform,
-                    "sklearn": sklearn_PCA.transform,
+                    "sklearn": _sklearn_PCA.transform,
                 },
                 X,
             )
 
         def _onedal_transform(self, X, queue=None):
-            check_is_fitted(self)
             if sklearn_check_version("1.0"):
-                self._check_feature_names(X, reset=False)
-            X = self._validate_data(
-                X,
-                dtype=[np.float64, np.float32],
-                reset=False,
-            )
+                X = validate_data(
+                    self,
+                    X,
+                    dtype=[np.float64, np.float32],
+                    reset=False,
+                )
+            else:
+                X = check_array(
+                    X,
+                    dtype=[np.float64, np.float32],
+                )
             self._validate_n_features_in_after_fitting(X)
 
             return self._onedal_estimator.predict(X, queue=queue)
@@ -401,10 +412,10 @@ if daal_check_version((2024, "P", 100)):
                     )
                 )
 
-        fit.__doc__ = sklearn_PCA.fit.__doc__
-        transform.__doc__ = sklearn_PCA.transform.__doc__
-        fit_transform.__doc__ = sklearn_PCA.fit_transform.__doc__
-        inverse_transform.__doc__ = sklearn_PCA.inverse_transform.__doc__
+        fit.__doc__ = _sklearn_PCA.fit.__doc__
+        transform.__doc__ = _sklearn_PCA.transform.__doc__
+        fit_transform.__doc__ = _sklearn_PCA.fit_transform.__doc__
+        inverse_transform.__doc__ = _sklearn_PCA.inverse_transform.__doc__
 
 else:
     from daal4py.sklearn.decomposition import PCA

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -52,7 +52,6 @@ def get_patch_map_core(preview=False):
                 EmpiricalCovariance as EmpiricalCovariance_sklearnex,
             )
             from .preview.decomposition import IncrementalPCA as IncrementalPCA_sklearnex
-            from .preview.linear_model import Ridge as Ridge_sklearnex
 
             # Since the state of the lru_cache without preview cannot be
             # guaranteed to not have already enabled sklearnex algorithms
@@ -83,14 +82,6 @@ def get_patch_map_core(preview=False):
                 ]
             ]
 
-            # Ridge
-            linear_model_module, _, _ = mapping["ridge"][0][0]
-            sklearn_obj = mapping["ridge"][0][1]
-            mapping.pop("ridge")
-            mapping["ridge"] = [
-                [(linear_model_module, "Ridge", Ridge_sklearnex), sklearn_obj]
-            ]
-
         return mapping
 
     from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms
@@ -492,7 +483,7 @@ def patch_sklearn(name=None, verbose=True, global_patch=False, preview=False):
     if verbose and sys.stderr is not None:
         sys.stderr.write(
             "Intel(R) Extension for Scikit-learn* enabled "
-            "(https://github.com/intel/scikit-learn-intelex)\n"
+            "(https://github.com/uxlfoundation/scikit-learn-intelex)\n"
         )