scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

scikit_learn_intelex-2025.5.0.data/data/Lib/site-packages/daal4py/mb/logistic_regression_builders.py

@@ -0,0 +1,217 @@
+# Copyright contributors to the oneDAL project
+#
+# 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 re
+import sys
+
+import numpy as np
+
+from .. import (
+    classifier_prediction_result,
+    logistic_regression_model_builder,
+    logistic_regression_prediction,
+)
+
+_docstring_X = """Parameters
+----------
+X : array-like(n_samples, n_features)
+    The features / covariates for each row. Can be passed as either a NumPy array
+    or as a sparse CSR array/matrix from SciPy. For faster results, use the same
+    dtype as what this object was built for."""
+if (sys.version_info.major == 3) and (sys.version_info.minor <= 12):
+    _docstring_X = re.sub("^", " " * 8, _docstring_X, flags=re.MULTILINE).strip()
+
+
+class LogisticDAALModel:
+    """
+    Logistic Regression Predictor
+
+    Creates a logistic regression or multionomial logistic regression model object
+    which can calculate fast predictions of different types (classes, probabilities,
+    logarithms of probabilities), from fitted coefficients and intercepts obtained
+    elsewhere (such as from :obj:`sklearn.linear_model.LogisticRegression`), making
+    the predictions either in double (``np.float64``) or single (``np.float32``)
+    precision.
+
+    See Also
+    --------
+    :obj:`sklearn.linear_model.LogisticRegression`, :obj:`sklearn.linear_model.SGDClassifier`,
+    :obj:`daal4py.classifier_prediction_result`.
+
+    Parameters
+    ----------
+    coefs : array(n_classes, n_features) or array(n_features,)
+        The fitted model coefficients. Note that only dense arrays are supported.
+        In the case of binary classification, can be passed as a 1D array or as a
+        2D array having a single row.
+    intercepts: array(n_classes) or float
+        The fitted intercepts. In the case of binary classification, must be passed
+        as either a scalar, or as a 1D array with a single entry.
+    dtype : np.float32 or np.float64
+        The dtype to use for the object.
+
+    Attributes
+    ----------
+    n_classes_ : int
+        Number of classes in the model.
+    n_features_in_ : int
+        Number of features in the model.
+    dtype_ : np.dtype
+        The dtype of the model
+    coef_ : array(n_classes, n_features)
+        The model coefficients
+    intercept_ : array(n_classes)
+        The model intercepts
+    """
+
+    def __init__(self, coefs, intercepts, dtype=np.float64):
+        assert dtype in [np.float32, np.float64]
+        coefs = np.require(coefs, requirements=["ENSUREARRAY"])
+        if len(coefs.shape) == 1:
+            coefs = coefs.reshape((1, -1))
+        self.n_features_in_ = coefs.shape[1]
+        self.n_classes_ = max(2, coefs.shape[0])
+        intercepts = np.require(intercepts, requirements=["ENSUREARRAY"]).reshape(-1)
+        if self.n_classes_ == 2:
+            assert len(intercepts) == 1
+        else:
+            assert intercepts.shape[0] == coefs.shape[0]
+        self._fptype = "float" if dtype == np.float32 else "double"
+        self.dtype_ = dtype
+        if coefs.dtype != self.dtype_:
+            coefs = coefs.astype(self.dtype_)
+        if intercepts.dtype != self.dtype_:
+            intercepts = intercepts.astype(self.dtype_)
+        builder = logistic_regression_model_builder(
+            n_classes=self.n_classes_, n_features=coefs.shape[1]
+        )
+        builder.set_beta(coefs, intercepts)
+        self._model = builder.model
+        self._alg_pred_class = logistic_regression_prediction(
+            nClasses=self.n_classes_,
+            fptype=self._fptype,
+            resultsToEvaluate="computeClassLabels",
+        )
+        self._alg_pred_prob = logistic_regression_prediction(
+            nClasses=self.n_classes_,
+            fptype=self._fptype,
+            resultsToEvaluate="computeClassProbabilities",
+        )
+        self._alg_pred_logprob = logistic_regression_prediction(
+            nClasses=self.n_classes_,
+            fptype=self._fptype,
+            resultsToEvaluate="computeClassLogProbabilities",
+        )
+
+    @property
+    def coef_(self):
+        return self._model.Beta[:, 1:]
+
+    @property
+    def intercept_(self):
+        return self._model.Beta[:, 0]
+
+    def predict(self, X) -> np.ndarray:
+        """
+        Predict most probable class
+
+        %docstring_X%
+
+        Returns
+        -------
+        classes : array(n_samples,)
+            The most probable class, as integer indexes
+        """
+        return (
+            self._alg_pred_class.compute(X, self._model)
+            .prediction.reshape(-1)
+            .astype(int)
+        )
+
+    predict.__doc__ = predict.__doc__.replace(r"%docstring_X%", _docstring_X)
+
+    def predict_proba(self, X) -> np.ndarray:
+        """
+        Predict probabilities of belonging to each class
+
+        %docstring_X%
+
+        Returns
+        -------
+        proba : array(n_samples, n_classes)
+            The predicted probabilities for each class.
+        """
+        return self._alg_pred_prob.compute(X, self._model).probabilities
+
+    predict_proba.__doc__ = predict_proba.__doc__.replace(r"%docstring_X%", _docstring_X)
+
+    def predict_log_proba(self, X) -> np.ndarray:
+        """
+        Predict log-probabilities of belonging to each class
+
+        %docstring_X%
+
+        Returns
+        -------
+        log_proba : array(n_samples, n_classes)
+            The logarithms of the predicted probabilities for each class.
+        """
+        return self._alg_pred_logprob.compute(X, self._model).logProbabilities
+
+    predict_log_proba.__doc__ = predict_log_proba.__doc__.replace(
+        r"%docstring_X%", _docstring_X
+    )
+
+    def predict_multiple(
+        self, X, classes: bool = True, proba: bool = True, log_proba: bool = True
+    ) -> classifier_prediction_result:
+        """
+        Make multiple prediction types at once
+
+        A method that can output the results from ``predict``, ``predict_proba``, and ``predict_log_proba``
+        all together in the same call more efficiently than computing them independently.
+
+        %docstring_X%
+        classes : bool
+            Whether to output class predictions (what is obtained from :meth:`predict`).
+        proba : bool
+            Whether to output per-class probability predictions (what is obtained from
+            :meth:`predict_proba`).
+        log_proba : bool
+            Whether to output per-class logarithms of probabilities (what is obtained
+            from :meth:`predict_log_proba`).
+
+        Returns
+        -------
+        predictions : classifier_prediction_result
+            An object of class :obj:`daal4py.classifier_prediction_result` with the requested
+            prediction types for the same ``X`` data.
+        """
+        pred_request = "|".join(
+            (["computeClassLabels"] if classes else [])
+            + (["computeClassProbabilities"] if proba else [])
+            + (["computeClassLogProbabilities"] if log_proba else [])
+        )
+        if not len(pred_request):
+            raise ValueError(
+                "Must request at least one of 'classes', 'proba', 'log_proba'."
+            )
+        return logistic_regression_prediction(
+            nClasses=self.n_classes_,
+            fptype=self._fptype,
+            resultsToEvaluate=pred_request,
+        ).compute(X, self._model)
+
+    predict_multiple.__doc__ = predict_multiple.__doc__.replace(
+        r"%docstring_X%", _docstring_X
+    )

scikit_learn_intelex-2025.4.0.data/data/Lib/site-packages/daal4py/mb/model_builders.py → scikit_learn_intelex-2025.5.0.data/data/Lib/site-packages/daal4py/mb/tree_based_builders.py

@@ -32,6 +32,15 @@ except (ImportError, ModuleNotFoundError):
 
 from sklearn.utils.metaestimators import available_if
 
+from .gbt_convertors import (
+    get_catboost_params,
+    get_gbt_model_from_catboost,
+    get_gbt_model_from_lightgbm,
+    get_gbt_model_from_xgboost,
+    get_lightgbm_params,
+    get_xgboost_params,
+)
+
 
 def parse_dtype(dt):
     if dt == np.double:
@@ -85,18 +94,18 @@ class GBTDAALBaseModel:
         self.n_features_in_ = len(params["features_info"]["float_features"])
 
     def _convert_model_from_lightgbm(self, booster):
-        lgbm_params = d4p.get_lightgbm_params(booster)
-        self.daal_model_ = d4p.get_gbt_model_from_lightgbm(booster, lgbm_params)
+        lgbm_params = get_lightgbm_params(booster)
+        self.daal_model_ = get_gbt_model_from_lightgbm(booster, lgbm_params)
         self._get_params_from_lightgbm(lgbm_params)
 
     def _convert_model_from_xgboost(self, booster):
-        xgb_params = d4p.get_xgboost_params(booster)
-        self.daal_model_ = d4p.get_gbt_model_from_xgboost(booster, xgb_params)
+        xgb_params = get_xgboost_params(booster)
+        self.daal_model_ = get_gbt_model_from_xgboost(booster, xgb_params)
         self._get_params_from_xgboost(xgb_params)
 
     def _convert_model_from_catboost(self, booster):
-        catboost_params = d4p.get_catboost_params(booster)
-        self.daal_model_ = d4p.get_gbt_model_from_catboost(booster)
+        catboost_params = get_catboost_params(booster)
+        self.daal_model_ = get_gbt_model_from_catboost(booster)
         self._get_params_from_catboost(catboost_params)
 
     def _convert_model(self, model):
@@ -108,85 +117,31 @@ class GBTDAALBaseModel:
 
         # Build GBTDAALClassifier from LightGBM
         if (submodule_name, class_name) == ("lightgbm.sklearn", "LGBMClassifier"):
-            if self_class_name == "GBTDAALClassifier":
-                self._convert_model_from_lightgbm(model.booster_)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALClassifier can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_lightgbm(model.booster_)
         # Build GBTDAALClassifier from XGBoost
         elif (submodule_name, class_name) == ("xgboost.sklearn", "XGBClassifier"):
-            if self_class_name == "GBTDAALClassifier":
-                self._convert_model_from_xgboost(model.get_booster())
-            else:
-                raise TypeError(
-                    f"Only GBTDAALClassifier can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_xgboost(model.get_booster())
         # Build GBTDAALClassifier from CatBoost
         elif (submodule_name, class_name) == ("catboost.core", "CatBoostClassifier"):
-            if self_class_name == "GBTDAALClassifier":
-                self._convert_model_from_catboost(model)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALClassifier can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_catboost(model)
         # Build GBTDAALRegressor from LightGBM
         elif (submodule_name, class_name) == ("lightgbm.sklearn", "LGBMRegressor"):
-            if self_class_name == "GBTDAALRegressor":
-                self._convert_model_from_lightgbm(model.booster_)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALRegressor can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_lightgbm(model.booster_)
         # Build GBTDAALRegressor from XGBoost
         elif (submodule_name, class_name) == ("xgboost.sklearn", "XGBRegressor"):
-            if self_class_name == "GBTDAALRegressor":
-                self._convert_model_from_xgboost(model.get_booster())
-            else:
-                raise TypeError(
-                    f"Only GBTDAALRegressor can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_xgboost(model.get_booster())
         # Build GBTDAALRegressor from CatBoost
         elif (submodule_name, class_name) == ("catboost.core", "CatBoostRegressor"):
-            if self_class_name == "GBTDAALRegressor":
-                self._convert_model_from_catboost(model)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALRegressor can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_catboost(model)
         # Build GBTDAALModel from LightGBM
         elif (submodule_name, class_name) == ("lightgbm.basic", "Booster"):
-            if self_class_name == "GBTDAALModel":
-                self._convert_model_from_lightgbm(model)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALModel can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_lightgbm(model)
         # Build GBTDAALModel from XGBoost
         elif (submodule_name, class_name) == ("xgboost.core", "Booster"):
-            if self_class_name == "GBTDAALModel":
-                self._convert_model_from_xgboost(model)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALModel can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_xgboost(model)
         # Build GBTDAALModel from CatBoost
         elif (submodule_name, class_name) == ("catboost.core", "CatBoost"):
-            if self_class_name == "GBTDAALModel":
-                self._convert_model_from_catboost(model)
-            else:
-                raise TypeError(
-                    f"Only GBTDAALModel can be created from\
-                                 {submodule_name}.{class_name} (got {self_class_name})"
-                )
+            self._convert_model_from_catboost(model)
         else:
             raise TypeError(f"Unknown model format {submodule_name}.{class_name}")
 
@@ -335,7 +290,61 @@ class GBTDAALBaseModel:
 
 
 class GBTDAALModel(GBTDAALBaseModel):
-    def predict(self, X, pred_contribs=False, pred_interactions=False):
+    """
+    Gradient Boosted Decision Tree Model
+
+    Model class offering accelerated predictions for gradient-boosted decision
+    tree models from other libraries.
+
+    Objects of this class are meant to be initialized from GBT model objects
+    created through other libraries, returning a different class which can calculate
+    predictions faster than the original library that created said model.
+
+    Can be created from model objects that meet all of the following criteria:
+
+    - Were produced from one of the following libraries: ``xgboost``, ``lightgbm``, or ``catboost``.
+      It can work with either the base booster classes of those libraries or with their
+      scikit-learn-compatible classes.
+    - Do not use categorical features.
+    - Are for regression or classification (e.g. no ranking). In the case of XGBoost objective
+      ``binary:logitraw``, it will create a classification model out of it, and in the case of
+      objective ``reg:logistic``, will create a regression model.
+    - Are not multi-output models. Note that multi-class classification **is** supported.
+
+    Parameters
+    ----------
+    model : booster object from another library
+        The fitted GBT model from which this object will be created. See rest of the documentation
+        for supported input types.
+    """
+
+    def __init__(self, model):
+        self._convert_model(model)
+        for type_str in ("xgboost", "lightgbm", "catboost"):
+            if type_str in str(type(model)):
+                self.model_type = type_str
+                break
+
+    def predict(
+        self, X, pred_contribs: bool = False, pred_interactions: bool = False
+    ) -> np.ndarray:
+        """
+        Compute model predictions on new data
+
+        Computes the predicted values of the response variable for new data given the features / covariates
+        for each row.
+
+        In the case of classification models, this will output the most probable class (see
+        :meth:`predict_proba` for probability predictions), while in the case of regression
+        models, will output values in the link scale (what XGBoost calls 'margin' and LightGBM
+        calls 'raw').
+
+        :param X: The features covariates. Should be an array of shape ``[num_samples, num_features]``.
+        :param bool pred_contribs: Whether to predict feature contributions. Result should have shape ``[num_samples, num_features+1]``, with the last column corresponding to the intercept. See :obj:`xgboost.Booster.predict` for more details about this type of computation.
+        :param bool pred_interactions: Whether to predict feature interactions. Result should have shape ``[num_samples, num_features+1, num_features+1]``, with the last position across the last two dimensions corresponding to the intercept. See :obj:`xgboost.Booster.predict` for more details about this type of computation.
+
+        :rtype: np.ndarray
+        """
         fptype = getFPType(X)
         if self._is_regression:
             return self._predict_regression(X, fptype, pred_contribs, pred_interactions)
@@ -348,30 +357,29 @@ class GBTDAALModel(GBTDAALBaseModel):
                 X, fptype, "computeClassLabels", pred_contribs, pred_interactions
             )
 
-    def _check_proba(self):
+    @property
+    def is_classifier_(self) -> bool:
+        """Whether this is a classification model"""
         return not self._is_regression
 
-    @available_if(_check_proba)
-    def predict_proba(self, X):
-        fptype = getFPType(X)
-        return self._predict_classification(X, fptype, "computeClassProbabilities")
+    @property
+    def is_regressor_(self) -> bool:
+        """Whether this is a regression model"""
+        return self._is_regression
 
+    def _check_proba(self):
+        return not self._is_regression
 
-def convert_model(model):
-    try:
-        gbm = GBTDAALModel()
-        gbm._convert_model(model)
-    except TypeError as err:
-        if "Only GBTDAALRegressor can be created" in str(err):
-            gbm = d4p.sklearn.ensemble.GBTDAALRegressor.convert_model(model)
-        elif "Only GBTDAALClassifier can be created" in str(err):
-            gbm = d4p.sklearn.ensemble.GBTDAALClassifier.convert_model(model)
-        else:
-            raise
+    @available_if(_check_proba)
+    def predict_proba(self, X) -> np.ndarray:
+        """
+        Predict class probabilities
 
-    for type_str in ("xgboost", "lightgbm", "catboost"):
-        if type_str in str(type(model)):
-            gbm.model_type = type_str
-            break
+        Computes the predicted probabilities of belonging to each class for each row in the
+        input data given the features / covariates. Output shape is ``[num_samples, num_classes]``.
 
-    return gbm
+        :param X: The features covariates. Should be an array of shape ``[num_samples, num_features]``.
+        :rtype: np.ndarray
+        """
+        fptype = getFPType(X)
+        return self._predict_classification(X, fptype, "computeClassProbabilities")

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/_n_jobs_support.py

@@ -82,7 +82,7 @@ def _run_with_n_jobs(method):
         if not isinstance(threading.current_thread(), threading._MainThread):
             warn(
                 "'Threading' parallel backend is not supported by "
-                "Intel(R) Extension for Scikit-learn*. "
+                "Extension for Scikit-learn*. "
                 "Falling back to usage of all available threads."
             )
             result = method(self, *args, **kwargs)
@@ -214,7 +214,11 @@ def control_n_jobs(decorated_methods: list = []):
             and "n_jobs : int" not in original_class.__doc__
         ):
             # Python 3.13 removed extra tab in class doc string
-            tab = "    " if sys.version_info.minor < 13 else ""
+            tab = (
+                "    "
+                if (sys.version_info.major == 3 and sys.version_info.minor < 13)
+                else ""
+            )
             parameters_doc_tail = f"\n{tab}Attributes"
             n_jobs_doc = f"""
 {tab}n_jobs : int, default=None

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/_utils.py

@@ -231,7 +231,7 @@ class PatchingConditionsChain:
         else:
             self.logger.debug(
                 f"{self.scope_name}: debugging for the patch is enabled to track"
-                " the usage of Intel® oneAPI Data Analytics Library (oneDAL)"
+                " the usage of oneAPI Data Analytics Library (oneDAL)"
             )
             for message in self.messages:
                 self.logger.debug(

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/cluster/dbscan.py

@@ -26,6 +26,7 @@ import daal4py
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import PatchingConditionsChain, getFPType, make2d, sklearn_check_version
+from ..utils.validation import check_feature_names
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
@@ -121,8 +122,7 @@ class DBSCAN(DBSCAN_original):
             if self.eps <= 0.0:
                 raise ValueError(f"eps == {self.eps}, must be > 0.0.")
 
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
 
         if sample_weight is not None:
             sample_weight = _check_sample_weight(sample_weight, X)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/cluster/k_means.py

@@ -36,6 +36,7 @@ import daal4py
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names, validate_data
 
 if sklearn_check_version("1.1"):
     from sklearn.utils.validation import _check_sample_weight, _is_arraylike_not_scalar
@@ -262,7 +263,8 @@ def _fit(self, X, y=None, sample_weight=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        X = self._validate_data(
+        X = validate_data(
+            self,
             X,
             accept_sparse="csr",
             dtype=[np.float64, np.float32],
@@ -310,8 +312,7 @@ def _fit(self, X, y=None, sample_weight=None):
             raise ValueError(f"n_init should be > 0, got {self.n_init} instead.")
 
         random_state = check_random_state(self.random_state)
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
 
         if self.max_iter <= 0:
             raise ValueError(f"max_iter should be > 0, got {self.max_iter} instead.")
@@ -413,8 +414,7 @@ def _fit(self, X, y=None, sample_weight=None):
 
 
 def _daal4py_check_test_data(self, X):
-    if sklearn_check_version("1.0"):
-        self._check_feature_names(X, reset=False)
+    check_feature_names(self, X, reset=False)
     X = check_array(
         X, accept_sparse="csr", dtype=[np.float64, np.float32], accept_large_sparse=False
     )
@@ -514,34 +514,6 @@ class KMeans(KMeans_original):
                 algorithm=algorithm,
             )
 
-    elif sklearn_check_version("1.0"):
-
-        @_deprecate_positional_args
-        def __init__(
-            self,
-            n_clusters=8,
-            *,
-            init="k-means++",
-            n_init=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(KMeans, self).__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,
-            )
-
     else:
 
         @_deprecate_positional_args
@@ -553,24 +525,20 @@ class KMeans(KMeans_original):
             n_init=10,
             max_iter=300,
             tol=1e-4,
-            precompute_distances="deprecated",
             verbose=0,
             random_state=None,
             copy_x=True,
-            n_jobs="deprecated",
-            algorithm="auto",
+            algorithm="lloyd" if sklearn_check_version("1.1") else "auto",
         ):
             super(KMeans, self).__init__(
                 n_clusters=n_clusters,
                 init=init,
                 max_iter=max_iter,
                 tol=tol,
-                precompute_distances=precompute_distances,
                 n_init=n_init,
                 verbose=verbose,
                 random_state=random_state,
                 copy_x=copy_x,
-                n_jobs=n_jobs,
                 algorithm=algorithm,
             )
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/decomposition/_pca.py

@@ -27,6 +27,7 @@ import daal4py
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names, validate_data
 
 if sklearn_check_version("1.4"):
     from sklearn.utils._array_api import get_namespace
@@ -223,7 +224,8 @@ class PCA(PCA_original):
                     "PCA with svd_solver='arpack' is not supported for Array API inputs."
                 )
 
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 dtype=[xp.float64, xp.float32],
                 accept_sparse=("csr", "csc"),
@@ -237,8 +239,8 @@ class PCA(PCA_original):
                     "PCA does not support sparse input. See "
                     "TruncatedSVD for a possible alternative."
                 )
-            X = self._validate_data(
-                X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
+            X = validate_data(
+                self, X, dtype=[np.float64, np.float32], ensure_2d=True, copy=False
             )
 
         if self.n_components is None:
@@ -291,9 +293,9 @@ class PCA(PCA_original):
 
         if not shape_good_for_daal or self._fit_svd_solver != "full":
             if sklearn_check_version("1.4"):
-                X = self._validate_data(X, copy=self.copy, accept_sparse=("csr", "csc"))
+                X = validate_data(self, X, copy=self.copy, accept_sparse=("csr", "csc"))
             else:
-                X = self._validate_data(X, copy=self.copy)
+                X = validate_data(self, X, copy=self.copy)
 
         _patching_status = PatchingConditionsChain("sklearn.decomposition.PCA.fit")
         _dal_ready = _patching_status.and_conditions(
@@ -333,9 +335,11 @@ class PCA(PCA_original):
     def _transform_daal4py(self, X, whiten=False, scale_eigenvalues=True, check_X=True):
         check_is_fitted(self)
 
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
-        X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=check_X)
+        check_feature_names(self, X, reset=False)
+        if sklearn_check_version("1.6"):
+            X = check_array(X, dtype=[np.float64, np.float32], ensure_all_finite=check_X)
+        else:
+            X = check_array(X, dtype=[np.float64, np.float32], force_all_finite=check_X)
         fpType = getFPType(X)
 
         tr_data = dict()