scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

scikit_learn_intelex-2025.6.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.6.0.data/data/Lib/site-packages/daal4py/mb/tree_based_builders.py

@@ -16,6 +16,7 @@
 
 # daal4py Model builders API
 
+import warnings
 from typing import Literal, Optional
 
 import numpy as np
@@ -32,6 +33,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:
@@ -82,21 +92,25 @@ class GBTDAALBaseModel:
     def _get_params_from_catboost(self, params):
         if "class_params" in params["model_info"]:
             self.n_classes_ = len(params["model_info"]["class_params"]["class_to_label"])
+        else:
+            self.n_classes_ = 1
         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)
+        self.supports_shap_ = self.n_classes_ < 3
 
     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)
+        self.supports_shap_ = self.n_classes_ < 3
 
     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_, self.supports_shap_ = get_gbt_model_from_catboost(booster)
         self._get_params_from_catboost(catboost_params)
 
     def _convert_model(self, model):
@@ -108,85 +122,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}")
 
@@ -294,21 +254,17 @@ class GBTDAALBaseModel:
                 X, fptype, pred_contribs, pred_interactions
             )
         except TypeError as e:
-            if "unexpected keyword argument 'resultsToCompute'" in str(e):
-                if pred_contribs or pred_interactions:
-                    # SHAP values requested, but not supported by this version
-                    raise TypeError(
-                        f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daalp4y"
-                    ) from e
+            if "unexpected keyword argument 'resultsToCompute'" in str(e) and (
+                pred_contribs or pred_interactions
+            ):
+                # SHAP values requested, but not supported by this version
+                raise TypeError(
+                    f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daalp4y"
+                ) from e
             else:
                 # unknown type error
                 raise
 
-        # fallback to calculation without `resultsToCompute`
-        predict_algo = d4p.gbt_regression_prediction(fptype=fptype)
-        predict_result = predict_algo.compute(X, self.daal_model_)
-        return predict_result.prediction.ravel()
-
     def _predict_regression_with_results_to_compute(
         self, X, fptype, pred_contribs=False, pred_interactions=False
     ):
@@ -335,43 +291,110 @@ 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.
+
+    Attributes
+    ----------
+    is_classifier_ : bool
+        Whether this is a classification model.
+    is_regressor_ : bool
+        Whether this is a regression model.
+    supports_shap_ : bool
+        Whether the model supports SHAP calculations.
+    """
+
+    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
+        """
+        if pred_contribs or pred_interactions:
+            if not self.supports_shap_:
+                raise TypeError("SHAP calculations are not available for this model.")
+            if self.model_type == "catboost":
+                warnings.warn(
+                    "SHAP values from models converted from CatBoost do not match "
+                    "against those of the original library. See "
+                    "https://github.com/catboost/catboost/issues/2556 for more details."
+                )
         fptype = getFPType(X)
         if self._is_regression:
             return self._predict_regression(X, fptype, pred_contribs, pred_interactions)
         else:
-            if (pred_contribs or pred_interactions) and self.model_type != "xgboost":
-                raise NotImplementedError(
-                    f"{'pred_contribs' if pred_contribs else 'pred_interactions'} is not implemented for classification models"
-                )
             return self._predict_classification(
                 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.6.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.6.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.6.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)