scikit-learn-intelex 2025.8.0__py310-none-win_amd64.whl → 2025.9.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.8.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/linear_model/logistic_regression.py

@@ -62,42 +62,81 @@ if daal_check_version((2024, "P", 1)):
                 **_sklearn_LogisticRegression._parameter_constraints
             }
 
-        def __init__(
-            self,
-            penalty="l2",
-            *,
-            dual=False,
-            tol=1e-4,
-            C=1.0,
-            fit_intercept=True,
-            intercept_scaling=1,
-            class_weight=None,
-            random_state=None,
-            solver="lbfgs",
-            max_iter=100,
-            multi_class="deprecated" if sklearn_check_version("1.5") else "auto",
-            verbose=0,
-            warm_start=False,
-            n_jobs=None,
-            l1_ratio=None,
-        ):
-            super().__init__(
-                penalty=penalty,
-                dual=dual,
-                tol=tol,
-                C=C,
-                fit_intercept=fit_intercept,
-                intercept_scaling=intercept_scaling,
-                class_weight=class_weight,
-                random_state=random_state,
-                solver=solver,
-                max_iter=max_iter,
-                multi_class=multi_class,
-                verbose=verbose,
-                warm_start=warm_start,
-                n_jobs=n_jobs,
-                l1_ratio=l1_ratio,
-            )
+        if sklearn_check_version("1.8"):
+
+            def __init__(
+                self,
+                penalty="l2",
+                *,
+                dual=False,
+                tol=1e-4,
+                C=1.0,
+                fit_intercept=True,
+                intercept_scaling=1,
+                class_weight=None,
+                random_state=None,
+                solver="lbfgs",
+                max_iter=100,
+                verbose=0,
+                warm_start=False,
+                n_jobs=None,
+                l1_ratio=None,
+            ):
+                super().__init__(
+                    penalty=penalty,
+                    dual=dual,
+                    tol=tol,
+                    C=C,
+                    fit_intercept=fit_intercept,
+                    intercept_scaling=intercept_scaling,
+                    class_weight=class_weight,
+                    random_state=random_state,
+                    solver=solver,
+                    max_iter=max_iter,
+                    verbose=verbose,
+                    warm_start=warm_start,
+                    n_jobs=n_jobs,
+                    l1_ratio=l1_ratio,
+                )
+
+        else:
+
+            def __init__(
+                self,
+                penalty="l2",
+                *,
+                dual=False,
+                tol=1e-4,
+                C=1.0,
+                fit_intercept=True,
+                intercept_scaling=1,
+                class_weight=None,
+                random_state=None,
+                solver="lbfgs",
+                max_iter=100,
+                multi_class="deprecated" if sklearn_check_version("1.5") else "auto",
+                verbose=0,
+                warm_start=False,
+                n_jobs=None,
+                l1_ratio=None,
+            ):
+                super().__init__(
+                    penalty=penalty,
+                    dual=dual,
+                    tol=tol,
+                    C=C,
+                    fit_intercept=fit_intercept,
+                    intercept_scaling=intercept_scaling,
+                    class_weight=class_weight,
+                    random_state=random_state,
+                    solver=solver,
+                    max_iter=max_iter,
+                    multi_class=multi_class,
+                    verbose=verbose,
+                    warm_start=warm_start,
+                    n_jobs=n_jobs,
+                    l1_ratio=l1_ratio,
+                )
 
         _onedal_cpu_fit = daal4py_fit
         decision_function = support_input_format(
@@ -167,6 +206,19 @@ if daal_check_version((2024, "P", 1)):
                 X,
             )
 
+        @wrap_output_data
+        def decision_function(self, X):
+            check_is_fitted(self)
+            return dispatch(
+                self,
+                "decision_function",
+                {
+                    "onedal": self.__class__._onedal_decision_function,
+                    "sklearn": _sklearn_LogisticRegression.decision_function,
+                },
+                X,
+            )
+
         @wrap_output_data
         def score(self, X, y, sample_weight=None):
             check_is_fitted(self)
@@ -214,7 +266,7 @@ if daal_check_version((2024, "P", 1)):
                     (self.solver == "newton-cg", "Only newton-cg solver is supported."),
                     (self.warm_start == False, "Warm start is not supported."),
                     (
-                        not (self.multi_class == "multinomial"),
+                        sklearn_check_version("1.8") or self.multi_class != "multinomial",
                         "multi_class='multinomial is not supported.",
                     ),
                     (
@@ -236,6 +288,7 @@ if daal_check_version((2024, "P", 1)):
                 "predict",
                 "predict_proba",
                 "predict_log_proba",
+                "decision_function",
                 "score",
             ]
 
@@ -249,7 +302,8 @@ if daal_check_version((2024, "P", 1)):
                 [
                     (n_samples > 0, "Number of samples is less than 1."),
                     (
-                        (not any([issparse(i) for i in data])) or _sparsity_enabled,
+                        (_sparsity_enabled and method_name != "decision_function")
+                        or (not any([issparse(i) for i in data])),
                         "Sparse input is not supported.",
                     ),
                     (
@@ -264,7 +318,13 @@ if daal_check_version((2024, "P", 1)):
         def _onedal_gpu_supported(self, method_name, *data):
             if method_name == "fit":
                 return self._onedal_gpu_fit_supported(method_name, *data)
-            if method_name in ["predict", "predict_proba", "predict_log_proba", "score"]:
+            if method_name in [
+                "predict",
+                "predict_proba",
+                "predict_log_proba",
+                "decision_function",
+                "score",
+            ]:
                 return self._onedal_gpu_predict_supported(method_name, *data)
             raise RuntimeError(
                 f"Unknown method {method_name} in {self.__class__.__name__}"
@@ -368,10 +428,26 @@ if daal_check_version((2024, "P", 1)):
             assert hasattr(self, "_onedal_estimator")
             return self._onedal_estimator.predict_log_proba(X, queue=queue)
 
+        def _onedal_decision_function(self, X, queue=None):
+            if queue is None or queue.sycl_device.is_cpu:
+                return super().decision_function(X)
+            X = validate_data(
+                self,
+                X,
+                reset=False,
+                accept_sparse=_sparsity_enabled,
+                accept_large_sparse=_sparsity_enabled,
+                dtype=[np.float64, np.float32],
+            )
+
+            assert hasattr(self, "_onedal_estimator")
+            return self._onedal_estimator.decision_function(X, queue=queue)
+
         fit.__doc__ = _sklearn_LogisticRegression.fit.__doc__
         predict.__doc__ = _sklearn_LogisticRegression.predict.__doc__
         predict_proba.__doc__ = _sklearn_LogisticRegression.predict_proba.__doc__
         predict_log_proba.__doc__ = _sklearn_LogisticRegression.predict_log_proba.__doc__
+        decision_function.__doc__ = _sklearn_LogisticRegression.decision_function.__doc__
         score.__doc__ = _sklearn_LogisticRegression.score.__doc__
 
 else:

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

@@ -26,7 +26,7 @@ from sklearn.linear_model import LogisticRegression as _sklearn_LogisticRegressi
 from sklearn.metrics import accuracy_score, log_loss
 from sklearn.model_selection import train_test_split
 
-from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.tests.utils._dataframes_support import (
     _as_numpy,
     _convert_to_dataframe,
@@ -108,6 +108,7 @@ if daal_check_version((2024, "P", 700)):
     @pytest.mark.parametrize(
         "dims", [(3007, 17, 0.05), (50000, 100, 0.01), (512, 10, 0.5)]
     )
+    @pytest.mark.allow_sklearn_fallback
     def test_csr(queue, dtype, dims):
         from sklearnex.linear_model import LogisticRegression
 
@@ -129,13 +130,16 @@ if daal_check_version((2024, "P", 700)):
             model.fit(X, y)
             pred = model.predict(X)
             prob = model.predict_proba(X)
+            raw = model.decision_function(X)
             model_sp.fit(X_sp, y)
             pred_sp = model_sp.predict(X_sp)
             prob_sp = model_sp.predict_proba(X_sp)
+            raw_sp = model.decision_function(X_sp)
 
         rtol = 2e-4
         assert_allclose(pred, pred_sp, rtol=rtol)
         assert_allclose(prob, prob_sp, rtol=rtol)
+        assert_allclose(raw, raw_sp, rtol=rtol)
         assert_allclose(model.coef_, model_sp.coef_, rtol=rtol)
         assert_allclose(model.intercept_, model_sp.intercept_, rtol=rtol)
 
@@ -180,13 +184,15 @@ def test_multinomial_logistic_regression_is_correct():
 
     X = np.array([[-1, 0], [0, 1], [1, 1]])
     y = np.array([2, 1, 0])
-    C = 3.0
+    params = {"C": 3.0}
+    # for sklearn 1.8 and onwards, non-binary class datasets will multinomial
+    if not sklearn_check_version("1.8"):
+        params["multi_class"] = "multinomial"
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=FutureWarning)
-        model_sklearn = _sklearn_LogisticRegression(C=C, multi_class="multinomial").fit(
-            X, y
-        )
-        model_sklearnex = LogisticRegression(C=C, multi_class="multinomial").fit(X, y)
+        model_sklearn = _sklearn_LogisticRegression(**params).fit(X, y)
+        model_sklearnex = LogisticRegression(**params).fit(X, y)
 
     try:
         np.testing.assert_allclose(model_sklearnex.coef_, model_sklearn.coef_)
@@ -196,7 +202,7 @@ def test_multinomial_logistic_regression_is_correct():
         def logistic_model_function(predicted_probabilities, coefs):
             neg_log_likelihood = X.shape[0] * log_loss(y, predicted_probabilities)
             sum_squares_coefs = np.dot(coefs.reshape(-1), coefs.reshape(-1))
-            return C * neg_log_likelihood + 0.5 * sum_squares_coefs
+            return params["C"] * neg_log_likelihood + 0.5 * sum_squares_coefs
 
         fn_sklearn = logistic_model_function(
             model_sklearn.predict_proba(X), model_sklearn.coef_
@@ -243,14 +249,14 @@ def test_binary_multinomial_probabilities(fit_intercept, C):
     )
     y_binary = np.array([1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int)
 
+    params = {"C": C, "fit_intercept": fit_intercept}
+    if not sklearn_check_version("1.8"):
+        params["multi_class"] = "multinomial"
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        model_sklearnex = LogisticRegression(
-            C=C, fit_intercept=fit_intercept, multi_class="multinomial"
-        ).fit(X, y_binary)
-        model_sklearn = _sklearn_LogisticRegression(
-            C=C, fit_intercept=fit_intercept, multi_class="multinomial"
-        ).fit(X, y_binary)
+        model_sklearnex = LogisticRegression(**params).fit(X, y_binary)
+        model_sklearn = _sklearn_LogisticRegression(**params).fit(X, y_binary)
     np.testing.assert_allclose(
         model_sklearnex.predict_proba(X),
         model_sklearn.predict_proba(X),
@@ -269,7 +275,9 @@ def test_binary_multinomial_probabilities(fit_intercept, C):
 # correctly when falling back.
 @pytest.mark.parametrize("fit_intercept", [False, True])
 @pytest.mark.parametrize("n_classes", [2, 3])
-@pytest.mark.parametrize("multi_class", ["auto", "multinomial"])
+@pytest.mark.parametrize(
+    "multi_class", ["auto", "multinomial"] if not sklearn_check_version("1.8") else [None]
+)
 @pytest.mark.parametrize("weighted", [False, True])
 @pytest.mark.allow_sklearn_fallback
 def test_warm_start_stateful(fit_intercept, n_classes, multi_class, weighted):
@@ -293,48 +301,40 @@ def test_warm_start_stateful(fit_intercept, n_classes, multi_class, weighted):
     # Note2: this will first compare the results after one iteration, and
     # if those already differ too much (which can be the case given numerical
     # differences), will then skip the rest of test that checks the warm starts.
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        model1 = _sklearn_LogisticRegression(
-            solver="lbfgs",
-            fit_intercept=fit_intercept,
-            multi_class=multi_class,
-            max_iter=1,
-            warm_start=True,
-        ).fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
-        model2 = LogisticRegression(
-            solver="lbfgs",
-            fit_intercept=fit_intercept,
-            multi_class=multi_class,
-            max_iter=1,
-            warm_start=True,
-        ).fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
+    params = {
+        "solver": "lbfgs",
+        "fit_intercept": fit_intercept,
+        "max_iter": 1,
+        "warm_start": True,
+    }
+    if not sklearn_check_version("1.8"):
+        params["multi_class"] = multi_class
+
+    model1 = _sklearn_LogisticRegression(**params)
+    model2 = LogisticRegression(**params)
+
+    for est in (model1, model2):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            est.fit(
+                X,
+                y,
+                np.ones(X.shape[0]) if weighted else None,
+            )
 
     try:
         np.testing.assert_allclose(model1.coef_, model2.coef_)
     except AssertionError:
         pytest.skip("Too large numerical differences for further comparisons")
 
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        model1.fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
-        model2.fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
+    for est in (model1, model2):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            est.fit(
+                X,
+                y,
+                np.ones(X.shape[0]) if weighted else None,
+            )
 
     np.testing.assert_allclose(model1.coef_, model2.coef_)
     if fit_intercept:
@@ -350,7 +350,9 @@ def test_warm_start_stateful(fit_intercept, n_classes, multi_class, weighted):
 # Note: other solvers do not have any internal state and are supposed to yield the
 # same result after one iteration given the current coefficients.
 @pytest.mark.parametrize("fit_intercept", [False, True])
-@pytest.mark.parametrize("multi_class", ["ovr", "multinomial"])
+@pytest.mark.parametrize(
+    "multi_class", ["ovr", "multinomial"] if not sklearn_check_version("1.8") else [None]
+)
 @pytest.mark.parametrize("weighted", [False, True])
 @pytest.mark.allow_sklearn_fallback
 def test_warm_start_binary(fit_intercept, multi_class, weighted):
@@ -365,39 +367,22 @@ def test_warm_start_binary(fit_intercept, multi_class, weighted):
         class_sep=0.5,
     )
 
+    params = {"random_state": 123, "solver": "newton-cg", "fit_intercept": fit_intercept}
+    if not sklearn_check_version("1.8"):
+        params["multi_class"] = multi_class
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        model1 = LogisticRegression(
-            random_state=123,
-            solver="newton-cg",
-            fit_intercept=fit_intercept,
-            multi_class=multi_class,
-            max_iter=2,
-        ).fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
-        model2 = (
-            LogisticRegression(
-                random_state=123,
-                solver="newton-cg",
-                fit_intercept=fit_intercept,
-                multi_class=multi_class,
-                max_iter=1,
-                warm_start=True,
-            )
-            .fit(
-                X,
-                y,
-                np.ones(X.shape[0]) if weighted else None,
-            )
-            .fit(
+        model1 = LogisticRegression(**params, max_iter=2)
+        model2 = LogisticRegression(**params, max_iter=1, warm_start=True)
+
+        # fit model2 twice using the same data to get 2 iterations (with warm_start)
+        for est in (model1, model2, model2):
+            est.fit(
                 X,
                 y,
                 np.ones(X.shape[0]) if weighted else None,
             )
-        )
 
     np.testing.assert_allclose(model1.coef_, model2.coef_)
     if fit_intercept:
@@ -405,7 +390,9 @@ def test_warm_start_binary(fit_intercept, multi_class, weighted):
 
 
 @pytest.mark.parametrize("fit_intercept", [False, True])
-@pytest.mark.parametrize("multi_class", ["ovr", "multinomial"])
+@pytest.mark.parametrize(
+    "multi_class", ["ovr", "multinomial"] if not sklearn_check_version("1.8") else [None]
+)
 @pytest.mark.parametrize("weighted", [False, True])
 @pytest.mark.allow_sklearn_fallback
 def test_warm_start_multinomial(fit_intercept, multi_class, weighted):
@@ -420,39 +407,22 @@ def test_warm_start_multinomial(fit_intercept, multi_class, weighted):
         class_sep=0.5,
     )
 
+    params = {"random_state": 123, "solver": "newton-cg", "fit_intercept": fit_intercept}
+    if not sklearn_check_version("1.8"):
+        params["multi_class"] = multi_class
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        model1 = LogisticRegression(
-            random_state=123,
-            solver="newton-cg",
-            fit_intercept=fit_intercept,
-            multi_class=multi_class,
-            max_iter=2,
-        ).fit(
-            X,
-            y,
-            np.ones(X.shape[0]) if weighted else None,
-        )
-        model2 = (
-            LogisticRegression(
-                random_state=123,
-                solver="newton-cg",
-                fit_intercept=fit_intercept,
-                multi_class=multi_class,
-                max_iter=1,
-                warm_start=True,
-            )
-            .fit(
-                X,
-                y,
-                np.ones(X.shape[0]) if weighted else None,
-            )
-            .fit(
+        model1 = LogisticRegression(**params, max_iter=2)
+        model2 = LogisticRegression(**params, max_iter=1, warm_start=True)
+
+        # fit model2 twice using the same data to get 2 iterations (with warm_start)
+        for est in (model1, model2, model2):
+            est.fit(
                 X,
                 y,
                 np.ones(X.shape[0]) if weighted else None,
             )
-        )
 
     np.testing.assert_allclose(model1.coef_, model2.coef_)
     if fit_intercept:
@@ -473,7 +443,9 @@ def test_warm_start_multinomial(fit_intercept, multi_class, weighted):
 @pytest.mark.skipif(
     not daal_check_version((2025, "P", 800)), reason="Bugs fixed in later oneDAL releases"
 )
-@pytest.mark.parametrize("multi_class", ["auto", "multinomial"])
+@pytest.mark.parametrize(
+    "multi_class", ["auto", "multinomial"] if not sklearn_check_version("1.8") else [None]
+)
 @pytest.mark.parametrize("C", [1, 0.2, 20.0])
 @pytest.mark.parametrize("solver", ["lbfgs", "newton-cg"])
 @pytest.mark.parametrize("n_classes", [2, 3])
@@ -491,24 +463,17 @@ def test_custom_solvers_are_correct(multi_class, C, solver, n_classes):
         class_sep=0.25,
     )
 
+    params = {"C": C}
+    if not sklearn_check_version:
+        params["multi_class"] = multi_class
+
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        model_sklearn = _sklearn_LogisticRegression(
-            C=C,
-            multi_class=multi_class,
-        ).fit(X, y)
-        model_sklearnex = LogisticRegression(
-            C=C, solver=solver, multi_class=multi_class, max_iter=1_000, tol=1e-8
-        ).fit(X, y)
+        model_sklearn = _sklearn_LogisticRegression(**params).fit(X, y)
+        params["solver"] = solver
+        model_sklearnex = LogisticRegression(**params, max_iter=1_000, tol=1e-8).fit(X, y)
         model_sklearnex_refitted = (
-            LogisticRegression(
-                C=C,
-                solver=solver,
-                multi_class=multi_class,
-                max_iter=1_000,
-                tol=1e-8,
-                warm_start=True,
-            )
+            LogisticRegression(**params, max_iter=1_000, tol=1e-8, warm_start=True)
             .fit(X, y)
             .fit(X, y)
         )
@@ -571,7 +536,30 @@ def test_gpu_logreg_prediction_shapes(dataframe, queue):
     pred = model.predict(X)
     pred_proba = model.predict_proba(X)
     pred_log_proba = model.predict_log_proba(X)
+    pred_decision_function = model.decision_function(X)
 
     np.testing.assert_array_equal(pred.shape, (X.shape[0],))
     np.testing.assert_array_equal(pred_proba.shape, (X.shape[0], 2))
     np.testing.assert_array_equal(pred_log_proba.shape, (X.shape[0], 2))
+    np.testing.assert_array_equal(pred_decision_function.shape, (X.shape[0],))
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 900)), reason="Bugs fixed in later oneDAL releases"
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_log_proba_doesnt_return_inf(dataframe, queue):
+    from sklearnex.linear_model import LogisticRegression
+
+    X, y = make_classification(random_state=123)
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
+
+    model = LogisticRegression(solver="newton-cg").fit(X, y)
+    X_problem = 1e10 * _as_numpy(model.coef_).reshape((1, -1))
+    X_problem = np.vstack([X_problem, -X_problem])
+
+    pred_log_proba = model.predict_log_proba(X_problem)
+    pred_log_proba = _as_numpy(pred_log_proba)
+
+    assert not np.any(np.isinf(pred_log_proba))