fix linter again & adress pytest warning for future updates

Author: floriankozikowski

skglm/experimental/quantile_huber.py

@@ -6,63 +6,64 @@
 
 
 class QuantileHuber(BaseDatafit):
-    """Huber-smoothed Pinball loss for quantile regression.
-
-    This implements a smoothed approximation of the Pinball (quantile) loss
-    by applying Huber-style smoothing at the non-differentiable point. T
-    his formulation improves numerical stability and convergence
-    for gradient-based solvers, particularly on larger datasets.
-
-    Parameters
-    ----------
-    delta : float, positive
-        Width of the quadratic region around the origin. Larger values create
-        more smoothing. As delta approaches 0, this approaches the standard
-        Pinball loss.
-
-    quantile : float, between 0 and 1
-        The desired quantile level. For example, 0.5 corresponds to the median.
-
-    Notes
-    -----
-    The loss function is defined as:
-
-    .. math::
-        L(r) = \begin{cases}
-            \tau \frac{r^2}{2\delta} & \text{if } 0 < r \leq \delta \\
-            (1-\tau) \frac{r^2}{2\delta} & \text{if } -\delta \leq r < 0 \\
-            \tau (r - \frac{\delta}{2}) & \text{if } r > \delta \\
-            (1-\tau) (-r - \frac{\delta}{2}) & \text{if } r < -\delta
-        \end{cases}
-
-    where :math:`r = y - Xw` is the residual, :math:`\tau` is the target
-    quantile, and :math:`\delta` controls the smoothing region width.
-
-    The gradient is given by:
-
-    .. math::
-        \nabla L(r) = \begin{cases}
-            \tau \frac{r}{\delta} & \text{if } 0 < r \leq \delta \\
-            (1-\tau) \frac{r}{\delta} & \text{if } -\delta \leq r < 0 \\
-            \tau & \text{if } r > \delta \\
-            -(1-\tau) & \text{if } r < -\delta
-        \end{cases}
-
-    This formulation provides twice-differentiable smoothing while maintaining
-    quantile estimation properties. The approach is similar to convolution
-    smoothing with a uniform kernel.
-
-        Special cases:
-            - When :math:`\\tau = 0.5`, this reduces to the symmetric Huber
-            loss used for median regression.
-            - As :math:`\\delta \\to 0`, it converges to the standard
-            Pinball loss.
-
-    References
-    ----------
-    He, X., Pan, X., Tan, K. M., & Zhou, W. X. (2021).
-       "Smoothed Quantile Regression with Large-Scale Inference
-    """
+    r"""Huber-smoothed Pinball loss for quantile regression.
+
+        This implements a smoothed approximation of the Pinball (quantile) loss
+        by applying Huber-style smoothing at the non-differentiable point. T
+        his formulation improves numerical stability and convergence
+        for gradient-based solvers, particularly on larger datasets.
+
+        Parameters
+        ----------
+        delta : float, positive
+            Width of the quadratic region around the origin. Larger values
+            create more smoothing. As delta approaches 0, this approaches the
+            standard Pinball loss.
+
+        quantile : float, between 0 and 1
+            The desired quantile level. For example, 0.5 corresponds to the
+            median.
+
+        Notes
+        -----
+        The loss function is defined as:
+
+        .. math::
+            L(r) = \begin{cases}
+                \tau \frac{r^2}{2\delta} & \text{if } 0 < r \leq \delta \\
+                (1-\tau) \frac{r^2}{2\delta} & \text{if } -\delta \leq r < 0 \\
+                \tau (r - \frac{\delta}{2}) & \text{if } r > \delta \\
+                (1-\tau) (-r - \frac{\delta}{2}) & \text{if } r < -\delta
+            \end{cases}
+
+        where :math:`r = y - Xw` is the residual, :math:`\tau` is the target
+        quantile, and :math:`\delta` controls the smoothing region width.
+
+        The gradient is given by:
+
+        .. math::
+            \nabla L(r) = \begin{cases}
+                \tau \frac{r}{\delta} & \text{if } 0 < r \leq \delta \\
+                (1-\tau) \frac{r}{\delta} & \text{if } -\delta \leq r < 0 \\
+                \tau & \text{if } r > \delta \\
+                -(1-\tau) & \text{if } r < -\delta
+            \end{cases}
+
+        This formulation provides twice-differentiable smoothing while
+        maintaining quantile estimation properties. The approach is similar to
+        convolution smoothing with a uniform kernel.
+
+            Special cases:
+                - When :math:`\\tau = 0.5`, this reduces to the symmetric Huber
+                loss used for median regression.
+                - As :math:`\\delta \\to 0`, it converges to the standard
+                Pinball loss.
+
+        References
+        ----------
+        He, X., Pan, X., Tan, K. M., & Zhou, W. X. (2021).
+        "Smoothed Quantile Regression with Large-Scale Inference
+        """
 
     def __init__(self, delta, quantile):
         if not 0 < quantile < 1:

skglm/experimental/smooth_quantile_regressor.py

@@ -10,8 +10,9 @@
 class SmoothQuantileRegressor:
     """Progressive smoothing (homotopy) meta-solver.
 
-    This solver addresses convergence issues in non-smooth datafits like Pinball
-    (quantile regression) on large datasets (as discussed in GitHub issue #276).
+    This solver addresses convergence issues in non-smooth datafits like
+    Pinball(quantile regression) on large datasets
+    (as discussed in GitHub issue #276).
 
     It works by progressively solving a sequence of smoothed problems with
     decreasing smoothing parameter.
@@ -59,7 +60,8 @@ class SmoothQuantileRegressor:
 
     Examples
     --------
-    >>> from skglm.experimental.progressive_smoothing import ProgressiveSmoothingSolver
+    >>> from skglm.experimental.progressive_smoothing import
+        ProgressiveSmoothingSolver
     >>> import numpy as np
     >>> X = np.random.randn(1000, 10)
     >>> y = np.random.randn(1000)
@@ -81,7 +83,8 @@ def __init__(
         # if user stops above min_delta, append finer deltas
         min_delta = 1e-3
         if base_seq[-1] > min_delta:
-            extra = np.geomspace(base_seq[-1], min_delta, num=5, endpoint=False)[1:]
+            extra = np.geomspace(base_seq[-1], min_delta, num=5,
+                                 endpoint=False)[1:]
             base_seq = base_seq + list(extra)
         self.smoothing_sequence = base_seq
         self.quantile = float(quantile)
@@ -224,7 +227,8 @@ def fit(self, X, y):
         self.intercept_ = best_intercept
 
         if self.verbose:
-            print(f"[Final] Using smoothed solution with delta={best_delta:.3g}")
+            print(f"[Final] Using smoothed solution with delta"
+                  f"={best_delta:.3g}")
             print(f"  Best quantile error: {best_quantile_error:.3f}")
 
         self.stage_results_ = stage_results

skglm/experimental/tests/test_smooth_quantile_regressor.py

@@ -4,7 +4,9 @@
 from sklearn.linear_model import QuantileRegressor
 
 from skglm import GeneralizedLinearEstimator
-from skglm.experimental.smooth_quantile_regressor import SmoothQuantileRegressor
+from skglm.experimental.smooth_quantile_regressor import (
+    SmoothQuantileRegressor,
+)
 from skglm.experimental.pdcd_ws import PDCD_WS
 from skglm.experimental.quantile_regression import Pinball
 from skglm.penalties import L1
@@ -38,10 +40,13 @@ def test_issue276_regression():
     n_samples_small, n_samples_large = 100, 1000
     n_features = 10
 
-    # Create two datasets - small should work with PDCD_WS, large exhibits the issue
-    X_small, y_small = make_regression(n_samples=n_samples_small, n_features=n_features,
+    # Create two datasets, small should work with PDCD_WS,
+    # large exhibits the issue
+    X_small, y_small = make_regression(n_samples=n_samples_small,
+                                       n_features=n_features,
                                        noise=0.1, random_state=42)
-    X_large, y_large = make_regression(n_samples=n_samples_large, n_features=n_features,
+    X_large, y_large = make_regression(n_samples=n_samples_large,
+                                       n_features=n_features,
                                        noise=0.1, random_state=42)
 
     X_small = StandardScaler().fit_transform(X_small)
@@ -58,7 +63,8 @@ def test_issue276_regression():
                                  solver="highs").fit(X_large, y_large)
 
     # Verify PDCD_WS works fine on small dataset
-    pdcd_solver = PDCD_WS(max_iter=500, max_epochs=500, tol=1e-4, verbose=False)
+    pdcd_solver = PDCD_WS(max_iter=500, max_epochs=500, tol=1e-4,
+                          verbose=False)
     pdcd_solver.fit_intercept = True
 
     estimator_small = GeneralizedLinearEstimator(
@@ -71,7 +77,8 @@ def test_issue276_regression():
     pdcd_small_loss = pinball_loss(y_small, y_pred_pdcd_small, tau=tau)
 
     # Apply PDCD_WS to large dataset (should exhibit issue #276)
-    pdcd_solver = PDCD_WS(max_iter=500, max_epochs=200, tol=1e-4, verbose=False)
+    pdcd_solver = PDCD_WS(max_iter=500, max_epochs=200, tol=1e-4,
+                          verbose=False)
     pdcd_solver.fit_intercept = True
     estimator_large = GeneralizedLinearEstimator(
         datafit=Pinball(tau),
@@ -122,8 +129,6 @@ def test_issue276_regression():
         assert len(sqr.stage_results_) > 0, "Missing stage results" \
             "in SmoothQuantileRegressor"
 
-    return rel_gap_pdcd_small, rel_gap_pdcd_large, rel_gap_sqr_large
-
 
 def test_smooth_quantile_regressor_non_median():
     """
@@ -135,7 +140,8 @@ def test_smooth_quantile_regressor_non_median():
     """
     np.random.seed(42)
 
-    X, y = make_regression(n_samples=1000, n_features=10, noise=0.1, random_state=42)
+    X, y = make_regression(n_samples=1000, n_features=10, noise=0.1,
+                           random_state=42)
     X = StandardScaler().fit_transform(X)
 
     tau = 0.8
@@ -149,7 +155,8 @@ def test_smooth_quantile_regressor_non_median():
 
     # SmoothQuantileRegressor solution
     sqr = SmoothQuantileRegressor(
-        smoothing_sequence=[1.0, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.001],
+        smoothing_sequence=[1.0, 0.5, 0.2, 0.1, 0.05,
+                            0.02, 0.01, 0.005, 0.001],
         quantile=tau,
         alpha=alpha,
         verbose=False,
@@ -170,5 +177,3 @@ def test_smooth_quantile_regressor_non_median():
     n_neg = np.sum(residuals < 0)
     assert abs(n_pos / (n_pos + n_neg) - tau) < 0.1, \
         f"Residual distribution doesn't match target quantile {tau}"
-
-    return rel_gap