- allow user-specified range of regularization strengths

backend/src/logic.py

@@ -62,6 +62,7 @@ class PlotsData:
     reg_levels: list[float]
     unreg_solution: np.ndarray
     path: np.ndarray
+    path_reg_levels: np.ndarray
 
 
 def generate_dataset(
@@ -219,6 +220,8 @@ def compute_regularization_path(
     dataset: Dataset,
     loss_type: Literal["l1", "l2"],
     regularizer_type: Literal["l1", "l2"],
+    reg_level_range: tuple[float, float],
+    num_levels: int = 100,
 ) -> np.ndarray:
     X = dataset.X
     y = np.array(dataset.y)
@@ -242,8 +245,7 @@ def compute_regularization_path(
     objective = cp.Minimize(loss_expr + lambd * reg_expr)
     problem = cp.Problem(objective)
 
-    # todo - user defined reg levels
-    reg_levels = np.linspace(0.001, 50, 100)
+    reg_levels = np.linspace(reg_level_range[0], reg_level_range[1], num_levels)
 
     # solve with reg levels in descending order for using warm start
     w_solutions = []
@@ -268,6 +270,7 @@ def compute_plot_values(
     w1_range: tuple[float, float],
     w2_range: tuple[float, float],
     resolution: int,
+    path_reg_level_range: tuple[float, float],
 ) -> PlotsData:
     W1, W2 = build_parameter_grid(w1_range, w2_range, resolution)
     loss_values = compute_loss(dataset, W1, W2, loss_type)
@@ -278,7 +281,9 @@ def compute_plot_values(
         dataset,
         loss_type,
         regularizer_type,
+        path_reg_level_range,
     )
+    path_reg_levels = np.linspace(*path_reg_level_range, path.shape[0])
 
     return PlotsData(
         W1=W1,
@@ -289,6 +294,7 @@ def compute_plot_values(
         reg_levels=reg_levels,
         unreg_solution=unreg_solution,
         path=path,
+        path_reg_levels=path_reg_levels,
     )
 
 

backend/src/manager.py

@@ -158,6 +158,7 @@ class Manager:
         loss_type: str,
         regularizer_type: str,
         resolution: int,
+        reg_level_range: tuple[float, float],
     ) -> None:
         if self.dataset is None:
             raise ValueError("Dataset is not initialized")
@@ -177,6 +178,7 @@ class Manager:
             w1_range,
             w2_range,
             int(resolution),
+            reg_level_range,
         )
 
     def handle_generate_plots(
@@ -196,6 +198,7 @@ class Manager:
         loss_type: str,
         regularizer_type: str,
         resolution: int,
+        reg_level_range_input: str,
     ) -> tuple[Manager, Figure | None, Figure | None, Figure]:
         self.update_dataset(
             dataset_type,
@@ -212,15 +215,28 @@ class Manager:
             y_col,
         )
 
+        try:
+            reg_level_range = self._parse_range(reg_level_range_input)
+        except Exception as e:
+            raise ValueError(f"Invalid regularization level range: {e}")
+        if reg_level_range[0] < 0:
+            raise ValueError("Regularization level range cannot include negative values")
+
         if self.dataset.X.shape[1] > 2:
             self.plots_data = None
-            path = compute_regularization_path(self.dataset, loss_type, regularizer_type)
-            return self, None, None, self._generate_path_plot(path, self.dataset.feature_names)
+            path = compute_regularization_path(
+                self.dataset, loss_type, regularizer_type, reg_level_range
+            )
+            path_reg_levels = np.linspace(*reg_level_range, path.shape[0])
+            return self, None, None, self._generate_path_plot(
+                path, path_reg_levels, self.dataset.feature_names
+            )
 
         self.compute_plots_data(
             loss_type,
             regularizer_type,
             resolution,
+            reg_level_range,
         )
 
         if self.dataset is None or self.plots_data is None:
@@ -228,7 +244,11 @@ class Manager:
 
         contour_plot = self._generate_contour_plot(self.plots_data)
         data_plot = self._generate_data_plot(self.dataset)
-        path_plot = self._generate_path_plot(self.plots_data.path, self.dataset.feature_names)
+        path_plot = self._generate_path_plot(
+            self.plots_data.path,
+            self.plots_data.path_reg_levels,
+            self.dataset.feature_names,
+        )
         return self, contour_plot, data_plot, path_plot
 
     @staticmethod
@@ -309,9 +329,11 @@ class Manager:
         return fig
 
     @staticmethod
-    def _generate_path_plot(path: np.ndarray, feature_names: list[str] | None = None) -> Figure:
-        reg_levels = np.linspace(0.001, 50, path.shape[0])
-
+    def _generate_path_plot(
+        path: np.ndarray,
+        reg_levels: np.ndarray,
+        feature_names: list[str] | None = None,
+    ) -> Figure:
         fig, ax = plt.subplots(figsize=(8, 6))
         ax.set_xlabel("Regularization Strength")
         ax.set_ylabel("Weight")

frontends/gradio/main.py

@@ -68,6 +68,7 @@ def handle_generate_plots(
     loss_type: str,
     regularizer_type: str,
     resolution: int,
+    reg_level_range: str,
 ):
     try:
         result = manager.handle_generate_plots(
@@ -86,6 +87,7 @@ def handle_generate_plots(
             loss_type,
             regularizer_type,
             resolution,
+            reg_level_range,
         )
         show_2d = manager.dataset.X.shape[1] == 2
         return (*result, gr.update(visible=show_2d), gr.update(visible=show_2d),
@@ -97,6 +99,7 @@ def handle_generate_plots(
 
 def launch():
     default_dataset_type = "Generate"
+    default_dataset_name = "Synthetic (2 covariates)"
 
     default_function = "-50 * x1 + 30 * x2"
     default_x1_range = "-1, 1"
@@ -114,10 +117,11 @@ def launch():
     default_loss_type = "l2"
     default_regularizer_type = "l2"
     default_resolution = 100
+    default_reg_level_range = "0.001, 50"
 
     manager = Manager()
     manager, default_contour_plot, default_data_plot, default_path_plot = manager.handle_generate_plots(
-        default_dataset_type,
+        default_dataset_name,
         default_function,
         default_x1_range,
         default_x2_range,
@@ -132,6 +136,7 @@ def launch():
         default_loss_type,
         default_regularizer_type,
         default_resolution,
+        default_reg_level_range,
     )
 
     with gr.Blocks() as demo:
@@ -153,10 +158,10 @@ def launch():
                 with gr.Tab("Data"):
                     dataset_name = gr.Dropdown(
                         label="Dataset", choices=["Custom", *PREDEFINED_DATASETS],
-                        value="Custom", interactive=True,
+                        value=default_dataset_name, interactive=True,
                     )
                     gr.Markdown("Predefined datasets use standardized covariates and a centered target.")
-                    with gr.Group() as custom_controls:
+                    with gr.Group(visible=False) as custom_controls:
                         with gr.Row():
                             dataset_type = gr.Radio(
                                 label="Dataset type",
@@ -288,6 +293,12 @@ def launch():
                         step=1,
                         interactive=True,
                     )
+                    reg_level_range = gr.Textbox(
+                        label="Regularization level range",
+                        value=default_reg_level_range,
+                        placeholder="minimum, maximum",
+                        interactive=True,
+                    )
                     regenerate_plots_button2 = gr.Button("Regenerate Plots")
 
                 with gr.Tab("Usage"):
@@ -319,6 +330,7 @@ def launch():
                             loss_type_dropdown,
                             regularizer_type_dropdown,
                             resolution_slider,
+                            reg_level_range,
                         ],
                         outputs=[manager_state, main_plot, data_plot, path_plot,
                                  contour_tab, data_tab, plot_tabs, resolution_slider],

usage.md

@@ -11,7 +11,7 @@ In the data tab, select a predefined regression dataset, or choose **Custom** to
 
 ### Regularization
 
-Select your loss function and regularization type
+Select your loss function and regularization type. Set the regularization level range as two comma-separated values (for example, `0.001, 50`).
 
 ### Generating plots
 
@@ -22,7 +22,7 @@ Click **Regenerate Plots** to update plots with the current settings
 ### Contour Plot
 
 The contour plot shows the loss values and the regularization norms for the linear models on the dataset. The red path shows how the loss and regularization norm values
-change as the regularization strength moves from 10^{-4} to 10^4 (log scale). You can see that the path intersects where the loss and regularization contours are parallel.
+change across the selected regularization level range. You can see that the path intersects where the loss and regularization contours are parallel.
 
 
 ### Data Plot
@@ -33,4 +33,3 @@ The data plot shows the data points used to compute the loss values.
 ### Regularization path plot
 
 The regularization path plot shows regularization strength versus coefficient value for every covariate. Datasets with more than two covariates show only this plot. These match the values shown on the red regularization path in the contour plot.
-