Refactor code to separate frontend and backend

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: gray
 sdk: gradio
 sdk_version: 5.46.0
-app_file: regularization.py
+app_file: frontend.py
 pinned: false
 ---
 

backend.py

@@ -0,0 +1,263 @@
+from dataclasses import dataclass
+from typing import Literal
+
+import cvxpy as cp
+import numpy as np
+from sympy import Expr, lambdify
+
+
+
+@dataclass
+class DataGenerationOptions:
+    method: Literal["grid", "random"]
+    num_samples: int
+    noise: float = 0.
+
+
+@dataclass
+class Dataset:
+    x1: list[float]
+    x2: list[float]
+    y: list[float]
+
+
+@dataclass
+class PlotsData:
+    W1: np.ndarray
+    W2: np.ndarray
+    loss_values: np.ndarray
+    norms: np.ndarray
+    loss_levels: list[float]
+    reg_levels: list[float]
+    unreg_solution: np.ndarray
+    path: np.ndarray
+
+
+def generate_dataset(
+    function: Expr, 
+    x1_lim: tuple[int, int], 
+    x2_lim: tuple[int, int],
+    generation_options: DataGenerationOptions,
+) -> Dataset:
+    f = lambdify(('x1', 'x2'), function, modules='numpy')
+
+    if generation_options.method == 'grid':
+        x1 = np.linspace(x1_lim[0], x1_lim[1], int(np.sqrt(generation_options.num_samples)))
+        x2 = np.linspace(x2_lim[0], x2_lim[1], int(np.sqrt(generation_options.num_samples)))
+        X1, X2 = np.meshgrid(x1, x2)
+        X1_flat = X1.flatten()
+        X2_flat = X2.flatten()
+    elif generation_options.method == 'random':
+        X1_flat = np.random.uniform(x1_lim[0], x1_lim[1], generation_options.num_samples)
+        X2_flat = np.random.uniform(x2_lim[0], x2_lim[1], generation_options.num_samples)
+    else:
+        raise ValueError(f"Unknown generation method: {generation_options.method}")
+
+    Y = f(X1_flat, X2_flat)
+
+    if generation_options.noise > 0:
+        Y += np.random.normal(0, generation_options.noise, size=Y.shape)
+
+    return Dataset(x1=X1_flat.tolist(), x2=X2_flat.tolist(), y=Y.tolist())
+
+
+def load_dataset_from_csv(
+    file_path: str, header: bool, x1_col: int, x2_col: int, y_col: int
+) -> Dataset:
+    # data = np.loadtxt(file_path, delimiter=',', skiprows=1 if header else 0)
+    data = np.genfromtxt(file_path, delimiter=',', skip_header=1 if header else 0)
+    data = data[~np.isnan(data).any(axis=1)]  # remove rows with NaN values
+
+    x1 = data[:, x1_col].tolist()
+    x2 = data[:, x2_col].tolist()
+    y = data[:, y_col].tolist()
+    return Dataset(x1=x1, x2=x2, y=y)
+
+
+def build_parameter_grid(
+    w1_lim: tuple[float, float], 
+    w2_lim: tuple[float, float], 
+    min_num_points: int,
+) -> tuple[np.ndarray, np.ndarray]:
+    w1 = np.linspace(w1_lim[0], w1_lim[1], min_num_points)
+    w2 = np.linspace(w2_lim[0], w2_lim[1], min_num_points)
+
+    # make sure (0, 0) is included
+    if 0 not in w1:
+        w1 = np.insert(w1, np.searchsorted(w1, 0), 0)
+    if 0 not in w2:
+        w2 = np.insert(w2, np.searchsorted(w2, 0), 0)
+
+    W1, W2 = np.meshgrid(w1, w2)
+    return W1, W2
+
+
+def compute_loss(
+    dataset: Dataset, 
+    w1: np.ndarray, 
+    w2: np.ndarray,
+    loss: Literal["l1", "l2"],
+) -> np.ndarray:
+    x1 = np.array(dataset.x1)
+    x2 = np.array(dataset.x2)
+    y = np.array(dataset.y)
+    grid_size = w1.shape[0]
+
+    W = np.stack([w1.flatten(), w2.flatten()], axis=-1)  # (D^2, 2)
+    X = np.stack([x1, x2], axis=0)  # (2, N)
+    y_pred = W @ X
+
+    y = y.reshape(1, -1)
+
+    if loss == 'l2':
+        return np.mean((y - y_pred) ** 2, axis=1).reshape(grid_size, grid_size)
+    elif loss == 'l1':
+        return np.mean(np.abs(y - y_pred), axis=1).reshape(grid_size, grid_size)
+
+
+def compute_norms(
+    w1: np.ndarray, 
+    w2: np.ndarray, 
+    norm: Literal["l1", "l2"],
+) -> np.ndarray:
+    if norm == "l2":
+        return np.sqrt(w1 ** 2 + w2 ** 2)
+    elif norm == "l1":
+        return np.abs(w1) + np.abs(w2)
+
+
+def compute_loss_levels(
+    loss_values: np.ndarray,
+    norms: np.ndarray,
+    reg_levels: list[float],
+) -> list[float]:
+    levels = []
+    for reg_level in reg_levels:
+        satisfying = loss_values[norms <= reg_level]
+        if satisfying.size == 0:
+            raise ValueError(f"No satisfying loss level for reg_level {reg_level}")
+
+        optimal_satisfying = np.min(satisfying)
+        levels.append(optimal_satisfying)
+
+    # ensure ascending order and no duplicates
+    levels = list(set(levels))
+    levels = sorted(levels)
+
+    return levels
+
+
+def compute_unregularized_solution(
+    dataset: Dataset,
+    w1_range: tuple[float, float],
+    w2_range: tuple[float, float],
+    num_dots: int = 100,
+) -> np.ndarray:
+    x1 = np.array(dataset.x1)
+    x2 = np.array(dataset.x2)
+    y = np.array(dataset.y)
+
+    X = np.stack([x1, x2], axis=-1)  # (N, 2)
+
+    try:
+        # find point solution if exists
+        w_opt = np.linalg.solve(X.T @ X, X.T @ y)
+
+    except np.linalg.LinAlgError:
+        # the solutions are on a line
+        eig_vals, eig_vecs = np.linalg.eigh(X.T @ X)
+
+        line_direction = eig_vecs[:, np.argmin(eig_vals)]
+        m = line_direction[1] / line_direction[0]
+
+        candidate_w = np.linalg.lstsq(X, y, rcond=None)[0]
+        b = candidate_w[1] - m * candidate_w[0]
+
+        w1_opt = np.linspace(w1_range[0], w1_range[1], num_dots)
+        w2_opt = m * w1_opt + b
+        w_opt = np.stack((w1_opt, w2_opt), axis=-1)
+
+        mask = (w2_opt <= w2_range[1]) & (w2_opt >= w2_range[0])
+        w_opt = w_opt[mask]
+
+    return w_opt
+
+
+def compute_regularization_path(
+    dataset: Dataset,
+    loss_type: Literal["l1", "l2"],
+    regularizer_type: Literal["l1", "l2"],
+) -> np.ndarray:
+    x1 = np.array(dataset.x1)
+    x2 = np.array(dataset.x2)
+    y = np.array(dataset.y)
+
+    X = np.stack([x1, x2], axis=1)  # (N, 2)
+
+    w = cp.Variable(2)
+    lambd = cp.Parameter(nonneg=True)
+
+    if loss_type == "l2":
+        loss_expr = cp.sum_squares(y - X @ w)
+    elif loss_type == "l1":
+        loss_expr = cp.norm1(y - X @ w)
+    else:
+        raise ValueError(f"Unknown loss type: {loss_type}")
+
+    if regularizer_type == "l2":
+        reg_expr = cp.sum_squares(w)
+    elif regularizer_type == "l1":
+        reg_expr = cp.norm1(w)
+    else:
+        raise ValueError(f"Unknown regularizer type: {regularizer_type}")
+
+    objective = cp.Minimize(loss_expr + lambd * reg_expr)
+    problem = cp.Problem(objective)
+
+    # todo - user defined reg levels
+    reg_levels = np.logspace(-4, 4, 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)
+
+        if w.value is None:
+            w_solutions.append(np.array([np.nan, np.nan]))
+        else:
+            w_solutions.append(w.value.copy())
+
+    return np.array(w_solutions)
+
+
+def compute_plot_values(
+    dataset: Dataset,
+    loss_type: Literal["l1", "l2"],
+    regularizer_type: Literal["l1", "l2"],
+    reg_levels: list[float],
+    w1_range: tuple[float, float],
+    w2_range: tuple[float, float],
+    resolution: int,
+) -> PlotsData:
+    W1, W2 = build_parameter_grid(w1_range, w2_range, resolution)
+    loss_values = compute_loss(dataset, W1, W2, loss_type)
+    norms = compute_norms(W1, W2, regularizer_type)
+    loss_levels = compute_loss_levels(loss_values, norms, reg_levels)
+    unreg_solution = compute_unregularized_solution(dataset, w1_range, w2_range)
+    path = compute_regularization_path(
+        dataset,
+        loss_type,
+        regularizer_type,
+    )
+
+    return PlotsData(
+        W1=W1,
+        W2=W2,
+        loss_values=loss_values,
+        norms=norms,
+        loss_levels=loss_levels,
+        reg_levels=reg_levels,
+        unreg_solution=unreg_solution,
+        path=path,
+    )

frontend.py

@@ -0,0 +1,539 @@
+import io
+from typing import Literal
+
+import gradio as gr
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+import matplotlib.lines as mlines
+import numpy as np
+from sympy import sympify
+
+from backend import (
+    compute_plot_values, 
+    generate_dataset, 
+    load_dataset_from_csv, 
+    Dataset,
+    DataGenerationOptions,
+    PlotsData,
+)
+
+CSS = """
+.hidden-button {
+    display: none;
+}
+"""
+
+
+def get_dataset(
+    dataset_type: str,
+    function: str,
+    x1_range_input: str,
+    x2_range_input: str,
+    x_selection_method: str,
+    sigma: float,
+    nsample: int,
+    csv_file: str,
+    has_header: bool,
+    x1_col: int,
+    x2_col: int,
+    y_col: int,
+) -> Dataset:
+    if dataset_type == "Generate":
+        try:
+            function = sympify(function)
+        except Exception as e:
+            raise ValueError(f"Invalid function: {e}")
+
+        x1_range = tuple(float(x.strip()) for x in x1_range_input.split(","))
+        x2_range = tuple(float(x.strip()) for x in x2_range_input.split(","))
+
+        if (len(x1_range) != 2 or len(x2_range) != 2):
+            raise ValueError("x1_range and x2_range must be tuples of length 2")
+        
+        x_selection_method = x_selection_method.lower()
+        if x_selection_method not in ("grid", "random"):
+            raise ValueError(f"Invalid x_selection_method: {x_selection_method}")
+
+        dataset = generate_dataset(
+            function,
+            x1_range,
+            x2_range,
+            DataGenerationOptions(
+                x_selection_method,
+                nsample,
+                sigma,
+            )
+        )
+
+    elif dataset_type == "CSV":
+        try:
+            dataset = load_dataset_from_csv(
+                csv_file,
+                has_header,
+                x1_col,
+                x2_col,
+                y_col,
+            )
+        except Exception as e:
+            gr.Info(f"Error loading CSV: {e}")
+            raise e
+
+    else:
+        raise ValueError(f"Invalid dataset_type: {dataset_type}")
+
+    return dataset
+
+
+def parse_plot_settings(
+    dataset: Dataset,
+    loss_type: str,
+    regularizer_type: str,
+    reg_levels_input: str,
+    w1_range_input: str,
+    w2_range_input: str,
+    resolution: int,
+) -> tuple[Dataset, Literal["l1", "l2"], Literal["l1", "l2"], list[float], tuple[float, float], tuple[float, float], int]:
+    reg_levels = [float(x.strip()) for x in reg_levels_input.split(",")]
+    w1_range = tuple(float(x.strip()) for x in w1_range_input.split(","))
+    w2_range = tuple(float(x.strip()) for x in w2_range_input.split(","))
+
+    if loss_type not in ("l1", "l2"):
+        raise ValueError(f"Invalid loss_type: {loss_type}")
+    if regularizer_type not in ("l1", "l2"):
+        raise ValueError(f"Invalid regularizer_type: {regularizer_type}")
+
+    if len(w1_range) != 2 or len(w2_range) != 2:
+        raise ValueError("w1_range and w2_range must be tuples of length 2")
+
+    return (
+        dataset,
+        loss_type,
+        regularizer_type,
+        reg_levels,
+        w1_range,
+        w2_range,
+        resolution,
+    )
+
+
+def generate_contour_plot(
+    W1: np.ndarray,
+    W2: np.ndarray,
+    losses: np.ndarray,
+    norms: np.ndarray,
+    loss_levels: list[float],
+    reg_levels: list[float],
+    unreg_solution: np.ndarray,
+    path: np.ndarray,
+) -> Figure:
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.set_title("")
+    ax.set_xlabel("w1")
+    ax.set_ylabel("w2")
+
+    cmap = plt.get_cmap("viridis")   
+    N = len(reg_levels)
+    colors = [cmap(i / (N - 1)) for i in range(N)]
+
+    # regularizer contours
+    cs1 = ax.contour(W1, W2, norms, levels=reg_levels, colors=colors, linestyles="dashed")
+    ax.clabel(cs1, inline=True, fontsize=8) # show contour levels
+
+    # loss contours
+    cs2 = ax.contour(W1, W2, losses, levels=loss_levels, colors=colors[::-1])
+    ax.clabel(cs2, inline=True, fontsize=8)
+
+    # unregularized solution
+    if unreg_solution.ndim == 1:
+        ax.plot(unreg_solution[0], unreg_solution[1], "bx", markersize=5, label="unregularized solution")
+    else:
+        ax.plot(unreg_solution[:, 0], unreg_solution[:, 1], "b-", label="unregularized solution")
+
+    ax.plot(path[:, 0], path[:, 1], "r-", label="regularization path")
+
+    # legend
+    loss_line = mlines.Line2D([], [], color='black', linestyle='-', label='loss')
+    reg_line = mlines.Line2D([], [], color='black', linestyle='--', label='regularization')
+    handles = [loss_line, reg_line]
+    
+    path_line = mlines.Line2D([], [], color='red', linestyle='-', label='regularization path')
+    handles.append(path_line)
+
+    if unreg_solution.ndim == 1:
+        handles.append(
+            mlines.Line2D([], [], color='blue', marker='x', linestyle='None', label='unregularized solution')
+        )
+    else:
+        handles.append(
+            mlines.Line2D([], [], color='blue', linestyle='-', label='unregularized solution')
+        )
+
+    ax.legend(handles=handles)
+
+    ax.grid(True)
+
+    return fig
+
+
+def generate_data_plot(dataset: Dataset) -> Figure:
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.set_xlabel("x1")
+    ax.set_ylabel("x2")
+
+    sc = ax.scatter(dataset.x1, dataset.x2, c=dataset.y, cmap='viridis')
+    ax.grid(True)
+    fig.colorbar(sc, ax=ax)
+
+    return fig
+
+
+def generate_strength_plot(
+    path: np.ndarray, 
+    reg_levels: np.ndarray,
+):
+    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')
+    ax.legend()
+    ax.grid(True)
+
+    return fig
+
+
+def generate_all_plots(
+    dataset: Dataset,
+    plots_data: PlotsData,
+) -> tuple[Figure, Figure]:
+    contour_plot = generate_contour_plot(
+        plots_data.W1,
+        plots_data.W2,
+        plots_data.loss_values,
+        plots_data.norms,
+        plots_data.loss_levels,
+        plots_data.reg_levels,
+        plots_data.unreg_solution,
+        plots_data.path,
+    )
+
+    data_plot = generate_data_plot(
+        dataset
+    )
+
+    strength_plot = generate_strength_plot(
+        plots_data.path,
+        np.logspace(-4, 4, 100),
+    )
+
+    return contour_plot, data_plot, strength_plot
+
+
+def handle_dataset_type_change(dataset_type: Literal["Generate", "CSV"]):
+    if dataset_type == "Generate":
+        return (
+            gr.update(visible=True),  # function
+            gr.update(visible=True),  # x1_textbox
+            gr.update(visible=True),  # x2_textbox
+            gr.update(visible=True),  # x_selection_method
+            gr.update(visible=True),  # sigma
+            gr.update(visible=True),  # nsample
+            gr.update(visible=False), # csv_file
+            gr.update(visible=False), # has_header
+            gr.update(visible=False), # x1_col
+            gr.update(visible=False), # x2_col
+            gr.update(visible=False), # y_col
+        )
+    else:  # CSV
+        return (
+            gr.update(visible=False), # function
+            gr.update(visible=False), # x1_textbox
+            gr.update(visible=False), # x2_textbox
+            gr.update(visible=False), # x_selection_method
+            gr.update(visible=False), # sigma
+            gr.update(visible=False), # nsample
+            gr.update(visible=True),  # csv_file
+            gr.update(visible=True),  # has_header
+            gr.update(visible=True),  # x1_col
+            gr.update(visible=True),  # x2_col
+            gr.update(visible=True),  # y_col
+        )
+
+
+def launch():
+    default_dataset_type = "Generate"
+
+    default_function = "-50 * x1 + 30 * x2"
+    default_x1_range = "-1, 1"
+    default_x2_range = "-1, 1"
+    default_x_selection_method = "Grid"
+    default_sigma = 0.1
+    default_num_points = 100
+
+    default_csv_file = ""
+    default_has_header = False
+    default_x1_col = 0
+    default_x2_col = 1
+    default_y_col = 2
+
+    default_loss_type = "l2"
+    default_regularizer_type = "l2"
+    default_reg_levels = "10, 20, 30"
+    default_w1_range = "-100, 100"
+    default_w2_range = "-100, 100"
+    default_resolution = 100
+
+    with gr.Blocks() as demo:
+        gr.HTML("<div style='text-align:left; font-size:40px; font-weight: bold;'>Regularization visualizer</div>")
+
+        dataset = gr.State(
+            get_dataset(
+                default_dataset_type,
+                default_function,
+                default_x1_range,
+                default_x2_range,
+                default_x_selection_method,
+                default_sigma,
+                default_num_points,
+                default_csv_file,
+                default_has_header,
+                default_x1_col,
+                default_x2_col,
+                default_y_col,
+            )
+        )
+
+        # wrapped PlotsData
+        plots_data = gr.State(
+            compute_plot_values(
+                *parse_plot_settings(
+                    dataset.value,
+                    default_loss_type,
+                    default_regularizer_type,
+                    default_reg_levels,
+                    default_w1_range,
+                    default_w2_range,
+                    default_resolution,
+                )
+            )
+        )
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Tab("Contours"):
+                    main_plot = gr.Plot(
+                        value=generate_contour_plot(
+                            plots_data.value.W1,
+                            plots_data.value.W2,
+                            plots_data.value.loss_values,
+                            plots_data.value.norms,
+                            plots_data.value.loss_levels,
+                            plots_data.value.reg_levels,
+                            plots_data.value.unreg_solution,
+                            plots_data.value.path,
+                        )
+                    )
+                with gr.Tab("Data"):
+                    # todo
+                    data_plot = gr.Plot(
+                        value=generate_data_plot(
+                            dataset.value
+                        )
+                    )
+                with gr.Tab("Strength"):
+                    # todo
+                    strength_plot = gr.Plot(
+                        value=generate_strength_plot(
+                            plots_data.value.path,
+                            np.logspace(-4, 4, 100),  # todo
+                        )
+                    )
+
+            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,
+                        )
+                        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,
+                        )
+                        nsample = gr.Number(
+                            label="Number of points", 
+                            value=default_num_points,
+                            interactive=True,
+                        )
+
+                    with gr.Row():
+                        csv_file = gr.File(
+                            label="Upload CSV file - must have columns: (x1, x2, y)", 
+                            file_types=['.csv'],
+                            visible=False,  # function mode is default
+                        )
+
+                    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,
+                        )
+                        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,
+                        ],
+                    )
+
+                with gr.Tab("Regularization"):
+                    with gr.Row():
+                        loss_type_dropdown = gr.Dropdown(
+                            label="Loss type",
+                            choices=["l1", "l2"],
+                            value=default_loss_type,
+                            interactive=True,
+                        )
+
+                    with gr.Row():
+                        regularizer_type_dropdown = gr.Dropdown(
+                            label="Regularizer type",
+                            choices=["l1", "l2"],
+                            value=default_regularizer_type,
+                            interactive=True,
+                        )
+                        regularizer_levels_textbox = gr.Textbox(
+                            label="Regularization levels (comma-separated)",
+                            value=default_reg_levels,
+                            interactive=True,
+                        )
+
+                    with gr.Row():
+                        w1_range_textbox = gr.Textbox(
+                            label="w1 range (min,max)",
+                            value=default_w1_range,
+                            interactive=True,
+                        )
+                        w2_range_textbox = gr.Textbox(
+                            label="w2 range (min,max)",
+                            value=default_w2_range,
+                            interactive=True,
+                        )
+
+                    resolution_slider = gr.Slider(
+                        label="Grid resolution",
+                        value=default_resolution,
+                        minimum=100,
+                        maximum=400,
+                        step=1,
+                        interactive=True,
+                    )
+
+                    gr.Button("Generate Plots").click(
+                        fn=get_dataset,
+                        inputs=[
+                            dataset_type,
+                            function,
+                            x1_textbox,
+                            x2_textbox,
+                            x_selection_method,
+                            sigma,
+                            nsample,
+                            csv_file,
+                            has_header,
+                            x1_col,
+                            x2_col,
+                            y_col,
+                        ],
+                        outputs=[dataset],
+                    ).then(
+                        fn=lambda *args: compute_plot_values(*parse_plot_settings(*args)),
+                        inputs=[
+                            dataset,
+                            loss_type_dropdown,
+                            regularizer_type_dropdown,
+                            regularizer_levels_textbox,
+                            w1_range_textbox,
+                            w2_range_textbox,
+                            resolution_slider,
+                        ],
+                        outputs=[plots_data],
+                    ).then(
+                        fn=generate_all_plots,
+                        inputs=[dataset, plots_data],
+                        outputs=[main_plot, data_plot, strength_plot],
+                    )
+
+                with gr.Tab("Export"):
+                    pass
+
+                with gr.Tab("Usage"):
+                    pass
+
+    demo.launch(css=CSS)
+
+
+if __name__ == "__main__":
+    launch()

requirements.txt

@@ -1,8 +1,9 @@
+cvxpy
 matplotlib
+mpu
 numpy
 pandas
-scikit-learn
-mpu
-numexpr
 pillow
 plotly
+scikit-learn
+sympy