initial commit

README.md

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

regularization.py

@@ -0,0 +1,286 @@
+from collections import deque
+from pathlib import Path
+import pickle
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import inspect
+import numpy as np
+import pandas as pd
+import io
+from jinja2 import Template
+from PIL import Image
+import sklearn
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import LinearSVC
+from sklearn.datasets import load_iris
+from sklearn.metrics import classification_report, mean_squared_error, mean_absolute_error
+from sklearn.datasets import make_regression
+from sklearn.linear_model import Ridge
+from sklearn.linear_model import Lasso
+
+import traceback
+import yaml
+
+import logging
+logging.basicConfig(
+    level=logging.INFO,  # set minimum level to capture (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    format="%(asctime)s [%(levelname)s] %(message)s",  # log format
+)
+logger = logging.getLogger("ELVIS")
+
+def min_corresponding_entries(W1, W2, w1, tol=0.1):
+    #mask = np.isclose(W1, w1, atol=tol, rtol=0)
+    mask = (W1 <= w1)
+    #print(W1.max(), W1.min(), w1)
+
+    values = W2[mask]
+
+    if values.size == 0:
+        raise ValueError("No entries in W1 approximately equal to w1")
+
+    return np.min(values)
+
+class Regularization:
+    def __init__(self, width, height):
+        # initialized in draw_plot
+        #self.canvas_width = -1
+        #self.canvas_height = -1
+
+        self.canvas_width = width
+        self.canvas_height = height
+
+        self.css ="""
+#my-button {
+    height: 30px;
+    font-size: 16px;
+}
+
+#rowheight {
+    height: 90px;
+}
+
+.hidden-button {
+    display: none;
+}
+
+.report-table {
+    border: 0 !important;
+}
+.report-table tr, .report-table th, .report-table td, .report-table tbody, .report-table thead {
+    border: 0 !important;
+    padding: 6px 12px;
+    text-align: center;
+}"""
+
+        # Regularization strengths
+        self.alphas = [0.01, 0.1, 1, 10, 100]
+
+        def l1_loss(y, pred):
+            return np.mean(abs(y - pred))
+
+        def l2_loss(y, pred):
+            return np.mean((y - pred)**2)
+
+        self.Losses = {#'l1': mean_absolute_error, # slow
+                       #'l1': lambda y, pred: np.mean(abs(y - pred)),
+                       'l1': l1_loss,
+                       #'l2': mean_squared_error, # slow
+                       #'l2': lambda y, pred: np.mean((y - pred)**2)
+                       'l2': l2_loss
+                       }
+        self.Regularizers = {'l1': lambda w: sum(abs(w)),
+                             'l2': np.linalg.norm
+                             }
+
+        #self.Model = Ridge #l2 loss + l2 reg
+        #self.Model = Lasso #l2 loss + l1 reg
+
+        self.loss_type = 'l2'
+        self.reg_type = 'l2'
+
+        self.Loss = self.Losses[self.loss_type]
+        self.Regularizer = self.Regularizers[self.reg_type]
+
+        self.reg_levels = [10, 20, 30]
+
+    def plot(self):
+        '''
+        '''
+
+        logger.info("Initializing figure")
+        fig = plt.figure(figsize=(self.canvas_width/100., self.canvas_height/100.0), dpi=100)
+        # set entire figure to be the canvas to allow simple conversion of mouse
+        # position to coordinates in the figure
+        ax = fig.add_axes([0., 0., 1., 1.]) # 
+        ax.margins(x=0, y=0) # no padding in both directions
+
+        # make a synthetic dataset with 2 features
+        X, y = make_regression(n_samples=200, n_features=2, noise=15, random_state=0)
+
+        # fit a regularized linear models and record parameters, regularizer value, and loss value
+        #solutions = []
+        #for alpha in self.alphas:
+            ## TODO: use PyTorch or cvx to implement a linear model class that supports
+            ## different types of losses and regularizers 
+            #model = self.Model(alpha=alpha, fit_intercept=False)  # no intercept
+            #model.fit(X, y)
+            #w = model.coef_
+            #loss = self.Loss(y, model.predict(X))
+            #solutions.append((alpha, w, self.Regularizer(w), loss))
+
+        # Extract contour levels from solutions
+        #reg_levels = [sol[2] for sol in solutions]
+        #reg_levels.reverse()
+        #loss_levels = [sol[3] for sol in solutions]
+ 
+        # build grid in parameter space
+        w1 = np.linspace(-100, 100, 400)
+        w2 = np.linspace(-100, 100, 400)
+        W1, W2 = np.meshgrid(w1, w2)
+
+        # compute regularizer surface
+        stacked = np.stack((W1, W2), axis=-1)
+        regs = np.apply_along_axis(self.Regularizer, -1, stacked)
+
+        logger.info("Computing losses " + str(self.Loss))
+        # compute loss surface
+        losses = np.zeros_like(W1)
+        for i in range(W1.shape[0]):
+            for j in range(W1.shape[1]):
+                w = np.array([W1[i, j], W2[i, j]])
+                y_pred = X @ w
+                losses[i, j] = self.Loss(y, y_pred)
+
+        logger.info("Computing loss levels")
+        reg_levels = self.reg_levels
+        loss_levels = [min_corresponding_entries(regs, losses, reg_level) for reg_level in reg_levels]
+        loss_levels.reverse()
+        print(reg_levels)
+        print(loss_levels)
+
+        # plot contour plots
+        fig = plt.figure(figsize=(5, 5))
+        ax = plt.gca()
+        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, regs, levels=reg_levels, colors=colors)
+        #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)
+
+        # plot solutions
+        #for alpha, w, norm, mse in solutions:
+            #ax.plot(w[0], w[1], "ro")
+            ##ax.text(w[0], w[1], f"α={alpha}", fontsize=8)
+
+        buf = io.BytesIO()
+        ax.figure.savefig(buf, format="png", bbox_inches="tight", pad_inches=0)
+        plt.close(fig)
+        buf.seek(0)
+        img = Image.open(buf)
+        
+        return img
+
+    def update_loss(self, loss_type):
+        self.loss_type = loss_type
+        self.Loss = self.Losses[loss_type]
+        return self.plot()
+
+    def update_regularizer(self, reg_type):
+        self.reg_type = reg_type
+        self.Regularizer = self.Regularizers[reg_type]
+
+        return self.plot()
+
+    def update_reg_levels(self, reg_levels):
+        self.reg_levels = [float(reg_level) for reg_level in reg_levels.split(",")]
+
+        return self.plot()
+
+    def update_resolution(self, num_dots):
+        self.num_dots = num_dots
+        return self.plot()
+
+    def launch(self):
+        # build the Gradio interface
+        with gr.Blocks(css=self.css) as demo:
+            # app title
+            gr.HTML("<div style='text-align:left; font-size:40px; font-weight: bold;'>Regularization visualizer</div>")
+
+            # GUI elements and layout 
+            with gr.Row():
+                with gr.Column(scale=2):
+                    self.data_image = gr.Image(value=self.plot(), container=True)
+
+                with gr.Column(scale=1): 
+                    with gr.Tab("Settings"):
+                        dataset_radio = gr.Radio(["make_regression", "Upload"], 
+                                                value="make_regression", label="Dataset type", elem_id="rowheight")
+
+                        # upload data
+                        file_chooser = gr.File(label="Choose a file", visible=False, elem_id="rowheight")
+                        self.file_chooser = file_chooser
+
+                        # loss type 
+                        loss_type = gr.Dropdown(choices=['l1', 'l2'],
+                                                label='Loss type',
+                                                value='l2',
+                                                visible=True)
+
+                        # regularizer type 
+                        regularizer_type = gr.Dropdown(choices=['l1', 'l2', 'elastic-net'],
+                                                       label='Regularizer type',
+                                                       value='l2',
+                                                       visible=True)
+
+                        # regularization strength
+                        #reg_textbox = gr.Textbox(label="Regularization constants")
+                        reg_textbox = gr.Textbox(label="Regularizer levels",
+                                                 value="10, 20, 30",
+                                                 interactive=True)
+                        self.reg_textbox = reg_textbox
+
+                    with gr.Tab("Export"):
+                        # use hidden download button to generate files on the fly
+                        # https://github.com/gradio-app/gradio/issues/9230#issuecomment-2323771634
+
+                        btn_export_data = gr.Button("Data")
+                        btn_export_data_hidden = gr.DownloadButton(label="You should not see this", elem_id="btn_export_data_hidden", elem_classes="hidden-button")
+                        
+                        btn_export_model = gr.Button('Model')
+                        btn_export_model_hidden = gr.DownloadButton(label="You should not see this", elem_id="btn_export_model_hidden", elem_classes="hidden-button")
+
+                        btn_export_code = gr.Button('Code')
+                        btn_export_code_hidden = gr.DownloadButton(label="You should not see this", elem_id="btn_export_code_hidden", elem_classes="hidden-button")
+
+                    with gr.Tab("Options"):
+                        slider = gr.Slider(minimum=100, maximum=1000, value=100, step=1, label="Resolution (#points)")
+
+                    with gr.Tab("Usage"):
+                        gr.Markdown(''.join(open('usage.md', 'r').readlines()))
+
+            
+                    # event handlers for GUI elements
+                    loss_type.change(fn=self.update_loss, inputs=loss_type,
+                                     outputs=self.data_image)
+                    regularizer_type.change(fn=self.update_regularizer,
+                                            inputs=regularizer_type, outputs=self.data_image)
+
+                    reg_textbox.submit(self.update_reg_levels, inputs=reg_textbox,
+                                       outputs=self.data_image)
+
+        demo.launch()
+
+visualizer = Regularization(width=1200, height=900)
+visualizer.launch()

usage.md

@@ -0,0 +1 @@
+**Quick start**