- added support for builtin datasets (2D or higher dimensional)

- fixed regularization path bug (weight increasing in strength)
- improve plots (use linspace instead of logspace for regularization strength, use average loss)

backend/src/logic.py

@@ -19,6 +19,37 @@ class Dataset:
     x1: list[float]
     x2: list[float]
     y: list[float]
+    features: np.ndarray | None = None
+    feature_names: list[str] | None = None
+
+    @property
+    def X(self) -> np.ndarray:
+        return self.features if self.features is not None else np.column_stack([self.x1, self.x2])
+
+
+PREDEFINED_DATASETS = ["Diabetes", "Synthetic (2 covariates)", "Synthetic (10 covariates)"]
+
+
+def load_predefined_dataset(name: str) -> Dataset:
+    from sklearn.datasets import load_diabetes, make_regression
+    from sklearn.preprocessing import StandardScaler
+
+    if name == "Diabetes":
+        data = load_diabetes()
+        X, y = data.data, data.target
+        names = list(data.feature_names)
+    elif name in PREDEFINED_DATASETS[1:]:
+        n_features = 2 if name == "Synthetic (2 covariates)" else 10
+        X, y = make_regression(
+            n_samples=100, n_features=n_features,
+            n_informative=min(5, n_features), noise=10, random_state=42,
+        )
+        names = [f"x{i + 1}" for i in range(n_features)]
+    else:
+        raise ValueError(f"Unknown predefined dataset: {name}")
+    X = StandardScaler().fit_transform(X)
+    y = y - np.mean(y)
+    return Dataset(X[:, 0].tolist(), X[:, 1].tolist(), y.tolist(), X, names)
 
 
 @dataclass
@@ -189,19 +220,15 @@ def compute_regularization_path(
     loss_type: Literal["l1", "l2"],
     regularizer_type: Literal["l1", "l2"],
 ) -> np.ndarray:
-    x1 = np.array(dataset.x1)
-    x2 = np.array(dataset.x2)
+    X = dataset.X
     y = np.array(dataset.y)
-
-    X = np.stack([x1, x2], axis=1)  # (N, 2)
-
-    w = cp.Variable(2)
+    w = cp.Variable(X.shape[1])
     lambd = cp.Parameter(nonneg=True)
 
     if loss_type == "l2":
-        loss_expr = cp.sum_squares(y - X @ w)
+        loss_expr = cp.sum_squares(y - X @ w)/(2*len(X))
     elif loss_type == "l1":
-        loss_expr = cp.norm1(y - X @ w)
+        loss_expr = cp.norm1(y - X @ w)/(len(X))
     else:
         raise ValueError(f"Unknown loss type: {loss_type}")
 
@@ -216,20 +243,21 @@ def compute_regularization_path(
     problem = cp.Problem(objective)
 
     # todo - user defined reg levels
-    reg_levels = np.logspace(-4, 4, 100)
+    reg_levels = np.linspace(0.001, 50, 100)
 
     # solve with reg levels in descending order for using warm start
     w_solutions = []
     for reg_level in sorted(reg_levels, reverse=True):
         lambd.value = reg_level
         problem.solve(warm_start=True)
+        #print(problem.status)
 
         if w.value is None:
-            w_solutions.append(np.array([np.nan, np.nan]))
+            w_solutions.append(np.full(X.shape[1], np.nan))
         else:
             w_solutions.append(w.value.copy())
 
-    return np.array(w_solutions)
+    return np.array(w_solutions[::-1])
 
 
 def compute_plot_values(
@@ -284,4 +312,4 @@ def compute_suggested_settings(
 
     reg_levels = [i / 4 * opt_norm for i in range(1, 4)]
 
-    return w1_range, w2_range, reg_levels
+    return w1_range, w2_range, reg_levels

backend/src/manager.py

@@ -19,6 +19,9 @@ from logic import (
     compute_suggested_settings,
     generate_dataset,
     load_dataset_from_csv,
+    load_predefined_dataset,
+    PREDEFINED_DATASETS,
+    compute_regularization_path,
 )
 
 
@@ -79,6 +82,8 @@ class Manager:
         x2_col: int,
         y_col: int,
     ) -> Dataset:
+        if dataset_type in PREDEFINED_DATASETS:
+            return load_predefined_dataset(dataset_type)
         if dataset_type == "Generate":
             x1, x2 = symbols("x1 x2")
             allowed_locals = {
@@ -191,7 +196,7 @@ class Manager:
         loss_type: str,
         regularizer_type: str,
         resolution: int,
-    ) -> tuple[Manager, Figure, Figure, Figure]:
+    ) -> tuple[Manager, Figure | None, Figure | None, Figure]:
         self.update_dataset(
             dataset_type,
             function,
@@ -207,6 +212,11 @@ class Manager:
             y_col,
         )
 
+        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)
+
         self.compute_plots_data(
             loss_type,
             regularizer_type,
@@ -218,8 +228,8 @@ class Manager:
 
         contour_plot = self._generate_contour_plot(self.plots_data)
         data_plot = self._generate_data_plot(self.dataset)
-        strength_plot = self._generate_strength_plot(self.plots_data.path)
-        return self, contour_plot, data_plot, strength_plot
+        path_plot = self._generate_path_plot(self.plots_data.path, self.dataset.feature_names)
+        return self, contour_plot, data_plot, path_plot
 
     @staticmethod
     def _generate_contour_plot(plots_data: PlotsData) -> Figure:
@@ -299,16 +309,17 @@ class Manager:
         return fig
 
     @staticmethod
-    def _generate_strength_plot(path: np.ndarray) -> Figure:
-        reg_levels = np.logspace(-4, 4, path.shape[0])
+    def _generate_path_plot(path: np.ndarray, feature_names: list[str] | None = None) -> Figure:
+        reg_levels = np.linspace(0.001, 50, path.shape[0])
 
         fig, ax = plt.subplots(figsize=(8, 6))
         ax.set_xlabel("Regularization Strength")
         ax.set_ylabel("Weight")
 
-        ax.plot(reg_levels, path[:, 0], "r-", label="w1")
-        ax.plot(reg_levels, path[:, 1], "b-", label="w2")
-        ax.set_xscale("log")
+        for i in range(path.shape[1]):
+            label = feature_names[i] if feature_names else f"w{i + 1}"
+            ax.plot(reg_levels, path[:, i], label=label)
+        #ax.set_xscale("log")
         ax.legend()
         ax.grid(True)
         return fig

frontends/gradio/main.py

@@ -1,7 +1,6 @@
 from typing import Literal
 
 import gradio as gr
-from matplotlib.figure import Figure
 
 import sys
 from pathlib import Path
@@ -12,6 +11,7 @@ if str(backend_src) not in sys.path:
     sys.path.append(str(backend_src))
 
 from manager import Manager
+from logic import PREDEFINED_DATASETS
 
 CSS = """
 .hidden-button {
@@ -53,6 +53,7 @@ def handle_dataset_type_change(dataset_type: Literal["Generate", "CSV"]):
 def handle_generate_plots(
     manager: Manager,
     dataset_type: str,
+    dataset_name: str,
     function: str,
     x1_range_input: str,
     x2_range_input: str,
@@ -67,10 +68,10 @@ def handle_generate_plots(
     loss_type: str,
     regularizer_type: str,
     resolution: int,
-) -> tuple[Manager, Figure, Figure, Figure]:
+):
     try:
-        return manager.handle_generate_plots(
-            dataset_type,
+        result = manager.handle_generate_plots(
+            dataset_type if dataset_name == "Custom" else dataset_name,
             function,
             x1_range_input,
             x2_range_input,
@@ -86,6 +87,10 @@ def handle_generate_plots(
             regularizer_type,
             resolution,
         )
+        show_2d = manager.dataset.X.shape[1] == 2
+        return (*result, gr.update(visible=show_2d), gr.update(visible=show_2d),
+                gr.update(selected="contours" if show_2d else "path"),
+                gr.update(visible=show_2d))
     except Exception as e:
         raise gr.Error("Error generating plots: " + str(e))
 
@@ -111,7 +116,7 @@ def launch():
     default_resolution = 100
 
     manager = Manager()
-    manager, default_contour_plot, default_data_plot, default_strength_plot = manager.handle_generate_plots(
+    manager, default_contour_plot, default_data_plot, default_path_plot = manager.handle_generate_plots(
         default_dataset_type,
         default_function,
         default_x1_range,
@@ -136,116 +141,127 @@ def launch():
 
         with gr.Row():
             with gr.Column(scale=2):
-                with gr.Tab("Contours"):
-                    main_plot = gr.Plot(value=default_contour_plot)
-                with gr.Tab("Data"):
-                    data_plot = gr.Plot(value=default_data_plot)
-                with gr.Tab("Strength"):
-                    strength_plot = gr.Plot(value=default_strength_plot)
+                with gr.Tabs() as plot_tabs:
+                    with gr.Tab("Contours", id="contours") as contour_tab:
+                        main_plot = gr.Plot(value=default_contour_plot)
+                    with gr.Tab("Data", id="data") as data_tab:
+                        data_plot = gr.Plot(value=default_data_plot)
+                    with gr.Tab("Regularization path", id="path"):
+                        path_plot = gr.Plot(value=default_path_plot)
 
             with gr.Column(scale=1):
                 with gr.Tab("Data"):
-                    with gr.Row():
-                        dataset_type = gr.Radio(
-                            label="Dataset type",
-                            choices=["Generate", "CSV"],
-                            value=default_dataset_type,
-                            interactive=True,
-                        )
-
-                    with gr.Row():
-                        function = gr.Textbox(
-                            label="Function (in terms of x1 and x2)",
-                            value=default_function,
-                            interactive=True,
-                        )
-
-                    with gr.Row():
-                        x1_textbox = gr.Textbox(
-                            label="x1 range",
-                            value=default_x1_range,
-                            interactive=True,
-                        )
-                        x2_textbox = gr.Textbox(
-                            label="x2 range",
-                            value=default_x2_range,
-                            interactive=True,
-                        )
+                    dataset_name = gr.Dropdown(
+                        label="Dataset", choices=["Custom", *PREDEFINED_DATASETS],
+                        value="Custom", interactive=True,
+                    )
+                    gr.Markdown("Predefined datasets use standardized covariates and a centered target.")
+                    with gr.Group() as custom_controls:
+                        with gr.Row():
+                            dataset_type = gr.Radio(
+                                label="Dataset type",
+                                choices=["Generate", "CSV"],
+                                value=default_dataset_type,
+                                interactive=True,
+                            )
+
+                        with gr.Row():
+                            function = gr.Textbox(
+                                label="Function (in terms of x1 and x2)",
+                                value=default_function,
+                                interactive=True,
+                            )
+
+                        with gr.Row():
+                            x1_textbox = gr.Textbox(
+                                label="x1 range",
+                                value=default_x1_range,
+                                interactive=True,
+                            )
+                            x2_textbox = gr.Textbox(
+                                label="x2 range",
+                                value=default_x2_range,
+                                interactive=True,
+                            )
                     
-                    with gr.Row():
-                        x_selection_method = gr.Radio(
-                            label="How to select x points",
-                            choices=["Grid", "Random"],
-                            value=default_x_selection_method,
-                            interactive=True,
-                        )
-
-                    with gr.Row():
-                        sigma = gr.Number(
-                            label="Gaussian noise standard deviation",
-                            value=default_sigma,
-                            interactive=True,
-                        )
-
-                    with gr.Row():
-                        nsample = gr.Slider(
-                            label="Number of points",
-                            value=default_num_points,
-                            interactive=True,
-                            minimum=2,  # todo - set to 1 after fixing weird cases
-                            maximum=100,
-                            step=1,
-                        )
-
-                    with gr.Row():
-                        csv_file = gr.File(
-                            label="Upload CSV file - must have columns: (x1, x2, y)",
-                            file_types=[".csv"],
-                            visible=False,
-                        )
-
-                    with gr.Row():
-                        has_header = gr.Checkbox(
-                            label="CSV has header row",
-                            value=default_has_header,
-                            visible=False,
-                        )
-
-                    with gr.Row():
-                        x1_col = gr.Number(
-                            label="x1 column index (0-based)",
-                            value=default_x1_col,
-                            visible=False,
-                        )
-                        x2_col = gr.Number(
-                            label="x2 column index (0-based)",
-                            value=default_x2_col,
-                            visible=False,
-                        )
+                        with gr.Row():
+                            x_selection_method = gr.Radio(
+                                label="How to select x points",
+                                choices=["Grid", "Random"],
+                                value=default_x_selection_method,
+                                interactive=True,
+                            )
+
+                        with gr.Row():
+                            sigma = gr.Number(
+                                label="Gaussian noise standard deviation",
+                                value=default_sigma,
+                                interactive=True,
+                            )
+
+                        with gr.Row():
+                            nsample = gr.Slider(
+                                label="Number of points",
+                                value=default_num_points,
+                                interactive=True,
+                                minimum=2,  # todo - set to 1 after fixing weird cases
+                                maximum=100,
+                                step=1,
+                            )
+
+                        with gr.Row():
+                            csv_file = gr.File(
+                                label="Upload CSV file - must have columns: (x1, x2, y)",
+                                file_types=[".csv"],
+                                visible=False,
+                            )
+
+                        with gr.Row():
+                            has_header = gr.Checkbox(
+                                label="CSV has header row",
+                                value=default_has_header,
+                                visible=False,
+                            )
+
+                        with gr.Row():
+                            x1_col = gr.Number(
+                                label="x1 column index (0-based)",
+                                value=default_x1_col,
+                                visible=False,
+                            )
+                            x2_col = gr.Number(
+                                label="x2 column index (0-based)",
+                                value=default_x2_col,
+                                visible=False,
+                            )
                     
-                    with gr.Row():
-                        y_col = gr.Number(
-                            label="y column index (0-based)",
-                            value=default_y_col,
-                            visible=False,
+                        with gr.Row():
+                            y_col = gr.Number(
+                                label="y column index (0-based)",
+                                value=default_y_col,
+                                visible=False,
+                            )
+
+                        dataset_type.change(
+                            fn=handle_dataset_type_change,
+                            inputs=[dataset_type],
+                            outputs=[
+                                function,
+                                x1_textbox,
+                                x2_textbox,
+                                x_selection_method,
+                                sigma,
+                                nsample,
+                                csv_file,
+                                has_header,
+                                x1_col,
+                                x2_col,
+                                y_col,
+                            ],
                         )
-
-                    dataset_type.change(
-                        fn=handle_dataset_type_change,
-                        inputs=[dataset_type],
-                        outputs=[
-                            function,
-                            x1_textbox,
-                            x2_textbox,
-                            x_selection_method,
-                            sigma,
-                            nsample,
-                            csv_file,
-                            has_header,
-                            x1_col,
-                            x2_col,
-                            y_col,
-                        ],
+                    dataset_name.change(
+                        fn=lambda name: gr.update(visible=name == "Custom"),
+                        inputs=[dataset_name], outputs=[custom_controls],
                     )
                     regenerate_plots_button1 = gr.Button("Regenerate Plots")
 
@@ -278,50 +294,35 @@ def launch():
                     with open(root_dir / "usage.md", "r") as f:
                         gr.Markdown(f.read())
 
-                regenerate_plots_button1.click(
-                    fn=handle_generate_plots,
-                    inputs=[
-                        manager_state,
-                        dataset_type,
-                        function,
-                        x1_textbox,
-                        x2_textbox,
-                        x_selection_method,
-                        sigma,
-                        nsample,
-                        csv_file,
-                        has_header,
-                        x1_col,
-                        x2_col,
-                        y_col,
-                        loss_type_dropdown,
-                        regularizer_type_dropdown,
-                        resolution_slider,
-                    ],
-                    outputs=[manager_state, main_plot, data_plot, strength_plot],
-                )
-                regenerate_plots_button2.click(
-                    fn=handle_generate_plots,
-                    inputs=[
-                        manager_state,
-                        dataset_type,
-                        function,
-                        x1_textbox,
-                        x2_textbox,
-                        x_selection_method,
-                        sigma,
-                        nsample,
-                        csv_file,
-                        has_header,
-                        x1_col,
-                        x2_col,
-                        y_col,
-                        loss_type_dropdown,
-                        regularizer_type_dropdown,
-                        resolution_slider,
-                    ],
-                    outputs=[manager_state, main_plot, data_plot, strength_plot],
-                )
+                for event in (
+                    regenerate_plots_button1.click,
+                    regenerate_plots_button2.click,
+                    dataset_name.change,
+                ):
+                    event(
+                        fn=handle_generate_plots,
+                        inputs=[
+                            manager_state,
+                            dataset_type,
+                            dataset_name,
+                            function,
+                            x1_textbox,
+                            x2_textbox,
+                            x_selection_method,
+                            sigma,
+                            nsample,
+                            csv_file,
+                            has_header,
+                            x1_col,
+                            x2_col,
+                            y_col,
+                            loss_type_dropdown,
+                            regularizer_type_dropdown,
+                            resolution_slider,
+                        ],
+                        outputs=[manager_state, main_plot, data_plot, path_plot,
+                                 contour_tab, data_tab, plot_tabs, resolution_slider],
+                    )
 
                     
     demo.launch(css=CSS)

usage.md

@@ -6,7 +6,7 @@ In this visualizer, you visualize the loss and regularization of linear regressi
 
 ### Data
 
-In the data tab, generate a dataset using a custom function or upload a csv file. Make sure the function depends on `x1` and `x2`.
+In the data tab, select a predefined regression dataset, or choose **Custom** to generate a dataset using a custom function or upload a CSV file. Predefined datasets have standardized covariates and a centered target. Make sure the function depends on `x1` and `x2`.
 
 
 ### Regularization
@@ -30,7 +30,7 @@ change as the regularization strength moves from 10^{-4} to 10^4 (log scale). Yo
 The data plot shows the data points used to compute the loss values.
 
 
-### Strength Plot
+### Regularization path plot
 
-The strenght plot is a line plot of regularization strength vs weight value for `w1` and `w2`. These match the values shown on the red regularization path in the contour 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.