fix linter

Author: floriankozikowski

skglm/experimental/quantile_huber.py

@@ -17,7 +17,8 @@ class QuantileHuber(BaseDatafit):
     ----------
     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.
+        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.
@@ -34,8 +35,8 @@ class QuantileHuber(BaseDatafit):
             (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.
+    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:
 
@@ -47,11 +48,15 @@ class QuantileHuber(BaseDatafit):
             -(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.
+    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.
+            - 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
     ----------
@@ -105,7 +110,11 @@ def get_global_lipschitz(self, X, y):
     def get_global_lipschitz_sparse(self, X_data, X_indptr, X_indices, y):
         n_samples = len(y)
         weight = max(self.quantile, 1 - self.quantile)
-        return weight * spectral_norm(X_data, X_indptr, X_indices, n_samples) ** 2 / (n_samples * self.delta)
+        return (
+            weight
+            * spectral_norm(X_data, X_indptr, X_indices, n_samples) ** 2
+            / (n_samples * self.delta)
+        )
 
     def _loss_and_grad_scalar(self, residual):
         tau, delta = self.quantile, self.delta
@@ -116,7 +125,9 @@ def _loss_and_grad_scalar(self, residual):
             if residual > 0:
                 return tau * residual**2 / (2 * delta), tau * residual / delta
             else:
-                return (1 - tau) * residual**2 / (2 * delta), (1 - tau) * residual / delta
+                return ((1 - tau) * residual**2 / (2 * delta), (1 - tau)
+                        * residual / delta
+                        )
 
         # Linear tails
         if residual > delta:

skglm/experimental/smooth_quantile_regressor.py

@@ -1,12 +1,9 @@
 import copy
-import warnings
 import numpy as np
 from scipy import sparse
 
 from skglm import GeneralizedLinearEstimator
 from skglm.penalties import L1
-from skglm.datafits import Huber
-from skglm.experimental.quantile_regression import Pinball
 from skglm.solvers import FISTA, LBFGS
 
 
@@ -144,16 +141,21 @@ def fit(self, X, y):
 
         extended_sequence = self.smoothing_sequence[:]
         fine_deltas = [0.15, 0.12, 0.1, 0.08, 0.06, 0.04, 0.02, 0.01]
-        extended_sequence = sorted(set(extended_sequence + fine_deltas), reverse=True)
+        extended_sequence = sorted(set(extended_sequence + fine_deltas),
+                                   reverse=True)
 
         # Progressive smoothing stages
         for stage, delta in enumerate(extended_sequence):
             if self.verbose:
-                print(f"[ProgressiveSmoothing] Stage {stage+1}/{len(extended_sequence)}: "
-                      f"delta = {delta:.3g}")
+                print(
+                    f"[ProgressiveSmoothing] Stage {stage + 1}/"
+                    f"{len(extended_sequence)}: "
+                    f"delta = {delta:.3g}"
+                )
 
             # Always use QuantileHuber for all quantile values
-            datafit = self._quantile_huber_cls(delta=delta, quantile=self.quantile)
+            datafit = self._quantile_huber_cls(delta=delta,
+                                               quantile=self.quantile)
 
             solver = copy.deepcopy(self.smooth_solver)
 
@@ -182,7 +184,8 @@ def fit(self, X, y):
 
             if self.verbose:
                 print(
-                    f"  Actual quantile: {actual_quantile:.3f}, Error: {quantile_error:.3f}")
+                    f"  Actual quantile: {actual_quantile:.3f},"
+                    f" Error: {quantile_error:.3f}")
 
             if quantile_error < best_quantile_error:
                 best_quantile_error = quantile_error
@@ -192,7 +195,8 @@ def fit(self, X, y):
 
                 if self.verbose:
                     print(
-                        f"  New best quantile at delta={delta:.3g}, error={quantile_error:.3f}")
+                        f"  New best quantile at delta={delta:.3g},"
+                        f" error={quantile_error:.3f}")
 
             # Record stage information
             obj_value = datafit.value(

skglm/experimental/tests/test_smooth_quantile_regressor.py

@@ -107,16 +107,20 @@ def test_issue276_regression():
     rel_gap_sqr_large = (sqr_large_loss - ref_large_loss) / ref_large_loss
 
     assert rel_gap_pdcd_small < 0.05, \
-        f"PDCD_WS should work well on small dataset (rel_gap={rel_gap_pdcd_small:.4f})"
+        f"PDCD_WS should work well on small dataset" \
+        f"(rel_gap={rel_gap_pdcd_small:.4f})"
 
     assert rel_gap_sqr_large < 0.05, \
-        f"SmoothQuantileRegressor failed to fix issue #276 (rel_gap={rel_gap_sqr_large:.4f})"
+        f"SmoothQuantileRegressor failed to fix issue #276" \
+        f"(rel_gap={rel_gap_sqr_large:.4f})"
 
     if rel_gap_pdcd_large > 0.05:
         assert sqr_large_loss < pdcd_large_loss, \
-            "SmoothQuantileRegressor should outperform direct PDCD_WS on large dataset"
+            "SmoothQuantileRegressor should outperform direct" \
+            "PDCD_WS on large dataset"
 
-        assert len(sqr.stage_results_) > 0, "Missing stage results in SmoothQuantileRegressor"
+        assert len(sqr.stage_results_) > 0, "Missing stage results" \
+            "in SmoothQuantileRegressor"
 
     return rel_gap_pdcd_small, rel_gap_pdcd_large, rel_gap_sqr_large
 
@@ -158,7 +162,8 @@ def test_smooth_quantile_regressor_non_median():
     rel_gap = (sqr_loss - ref_loss) / ref_loss
 
     assert rel_gap < 0.05, \
-        f"SmoothQuantileRegressor should work for non-median quantiles (rel_gap={rel_gap:.4f})"
+        f"SmoothQuantileRegressor should work for non-median quantiles" \
+        f"(rel_gap={rel_gap:.4f})"
 
     residuals = y - y_pred_sqr
     n_pos = np.sum(residuals > 0)