Update app.py

app.py

@@ -6,8 +6,7 @@ from sklearn.model_selection import train_test_split
 import matplotlib.cm as cm
 from sklearn.utils import shuffle
 from sklearn.utils import check_random_state
-from sklearn.cluster import MiniBatchKMeans
-from sklearn.cluster import KMeans
+from sklearn.linear_model import BayesianRidge
 
 theme = gr.themes.Monochrome(
     primary_hue="indigo",
@@ -17,126 +16,68 @@ theme = gr.themes.Monochrome(
 
 description = f"""
 ## Description
-This demo can be used to evaluate the ability of k-means initializations strategies to make the algorithm convergence robust as measured by the relative standard deviation of the inertia of the clustering (i.e. the sum of squared distances to the nearest cluster center).
-The dataset used for evaluation is a 2D grid of isotropic Gaussian clusters widely spaced.
-The Inertia plot shows the best inertia reached for each combination of the model (KMeans or MiniBatchKMeans), and either random initialization or k-means++ initialization.
-The Cluster Allocation plot demonstrates one single run of the MiniBatchKMeans estimator using random initialization. 
-The demo is based on the [scikit-learn docs](https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_stability_low_dim_dense.html#sphx-glr-auto-examples-cluster-plot-kmeans-stability-low-dim-dense-py)
-"""
-
-# k-means models can do several random inits so as to be able to trade
-# CPU time for convergence robustness
-n_init_range = np.array([1, 5, 10, 15, 20])
-
-# Datasets generation parameters
-scale = 0.1
-
-def make_data(random_state, n_samples_per_center, grid_size, scale):
-    random_state = check_random_state(random_state)
-    centers = np.array([[i, j] for i in range(grid_size) for j in range(grid_size)])
-    n_clusters_true, n_features = centers.shape
-
-    noise = random_state.normal(
-        scale=scale, size=(n_samples_per_center, centers.shape[1])
-    )
 
-    X = np.concatenate([c + noise for c in centers])
-    y = np.concatenate([[i] * n_samples_per_center for i in range(n_clusters_true)])
-    return shuffle(X, y, random_state=random_state)
+This demo computes a Bayesian Ridge Regression of Sinusoids.
 
-def quant_evaluation(n_runs, n_samples_per_center, grid_size):
-    
-    n_clusters = grid_size**2
+The demo is based on the [scikit-learn docs](https://scikit-learn.org/stable/auto_examples/linear_model/plot_bayesian_ridge_curvefit.html#sphx-glr-auto-examples-linear-model-plot-bayesian-ridge-curvefit-py)
+"""
 
-    plt.figure()
-    plots = []
-    legends = []
-    
-    cases = [
-        (KMeans, "k-means++", {}, "^-"),
-        (KMeans, "random", {}, "o-"),
-        (MiniBatchKMeans, "k-means++", {"max_no_improvement": 3}, "x-"),
-        (MiniBatchKMeans, "random", {"max_no_improvement": 3, "init_size": 500}, "d-"),
-    ]
+def func(x):
+    return np.sin(2 * np.pi * x)
+
+
+size = 25
+rng = np.random.RandomState(1234)
+x_train = rng.uniform(0.0, 1.0, size)
+y_train = func(x_train) + rng.normal(scale=0.1, size=size)
+x_test = np.linspace(0.0, 1.0, 100)
+
+n_order = 3
+X_train = np.vander(x_train, n_order + 1, increasing=True)
+X_test = np.vander(x_test, n_order + 1, increasing=True)
+reg = BayesianRidge(tol=1e-6, fit_intercept=False, compute_score=True)
+
+def curve_fit():
+    fig, axes = plt.subplots(1, 2, figsize=(8, 4))
+    for i, ax in enumerate(axes):
+    # Bayesian ridge regression with different initial value pairs
+        if i == 0:
+            init = [1 / np.var(y_train), 1.0]  # Default values
+        elif i == 1:
+            init = [1.0, 1e-3]
+            reg.set_params(alpha_init=init[0], lambda_init=init[1])
+        reg.fit(X_train, y_train)
+        ymean, ystd = reg.predict(X_test, return_std=True)
     
-    for factory, init, params, format in cases:
-        print("Evaluation of %s with %s init" % (factory.__name__, init))
-        inertia = np.empty((len(n_init_range), n_runs))
-    
-        for run_id in range(n_runs):
-            X, y = make_data(run_id, n_samples_per_center, grid_size, scale)
-            for i, n_init in enumerate(n_init_range):
-                km = factory(
-                    n_clusters=n_clusters,
-                    init=init,
-                    random_state=run_id,
-                    n_init=n_init,
-                    **params,
-                ).fit(X)
-                inertia[i, run_id] = km.inertia_
-        p = plt.errorbar(
-            n_init_range, inertia.mean(axis=1), inertia.std(axis=1), fmt=format
+        ax.plot(x_test, func(x_test), color="blue", label="sin($2\\pi x$)")
+        ax.scatter(x_train, y_train, s=50, alpha=0.5, label="observation")
+        ax.plot(x_test, ymean, color="red", label="predict mean")
+        ax.fill_between(
+            x_test, ymean - ystd, ymean + ystd, color="pink", alpha=0.5, label="predict std"
         )
-        plots.append(p[0])
-        legends.append("%s with %s init" % (factory.__name__, init))
-    
-    plt.xlabel("n_init")
-    plt.ylabel("inertia")
-    plt.legend(plots, legends)
-    plt.title("Mean inertia for various k-means init across %d runs" % n_runs)
-    return plt
-
-def qual_evaluation(random_state, n_samples_per_center, grid_size):
-    n_clusters = grid_size**2
-    X, y = make_data(random_state, n_samples_per_center, grid_size, scale)
-    km = MiniBatchKMeans(
-    n_clusters=n_clusters, init="random", n_init=1, random_state=random_state
-    ).fit(X)
-
-    plt.figure()
-    for k in range(n_clusters):
-        my_members = km.labels_ == k
-        color = cm.nipy_spectral(float(k) / n_clusters, 1)
-        plt.plot(X[my_members, 0], X[my_members, 1], ".", c=color)
-        cluster_center = km.cluster_centers_[k]
-        plt.plot(
-            cluster_center[0],
-            cluster_center[1],
-            "o",
-            markerfacecolor=color,
-            markeredgecolor="k",
-            markersize=6,
-        )
-        plt.title(
-            "Example cluster allocation with a single random init\nwith MiniBatchKMeans"
+        ax.set_ylim(-1.3, 1.3)
+        ax.legend()
+        title = "$\\alpha$_init$={:.2f},\\ \\lambda$_init$={}$".format(init[0], init[1])
+        if i == 0:
+            title += " (Default)"
+        ax.set_title(title, fontsize=12)
+        text = "$\\alpha={:.1f}$\n$\\lambda={:.3f}$\n$L={:.1f}$".format(
+            reg.alpha_, reg.lambda_, reg.scores_[-1]
         )
-    return plt
+        ax.text(0.05, -1.0, text, fontsize=12)
+    return fig
+
 
 with gr.Blocks(theme=theme) as demo:
     gr.Markdown('''
-            <h1 style='text-align: center'>Empirical evaluation of the impact of k-means initialization 📊</h1>
+            <h1 style='text-align: center'>Curve Fitting with Bayesian Ridge Regression 📈</h1>
         ''')
     gr.Markdown(description)
 
-    
-    gr.Markdown('''
-    ### Dataset Generation Parameters
-    ''')
-    with gr.Row():
-        n_runs = gr.Slider(minimum=1, maximum=10, step=1, value=5, label="Number of Evaluation Runs")
-        random_state = gr.Slider(minimum=0, maximum=2000, step=5, value=0, label="Random state")
-    
-    with gr.Row():    
-        n_samples_per_center = gr.Slider(minimum=50, maximum=200, step=10, value=100, label="Number of Samples per Center")
-        grid_size = gr.Slider(minimum=1, maximum=8, step=1, value=3, label="Grid Size") 
-
     with gr.Row():
-        run_button = gr.Button('Evaluate Inertia')
-        run_button_qual = gr.Button('Generate Cluster Allocations')
+        run_button = gr.Button('Fit the Curve')
     with gr.Row():
-        plot_inertia = gr.Plot()
-        plot_vis = gr.Plot()
-    run_button.click(fn=quant_evaluation, inputs=[n_runs, n_samples_per_center, grid_size], outputs=plot_inertia)
-    run_button_qual.click(fn=qual_evaluation, inputs=[random_state, n_samples_per_center, grid_size], outputs=plot_vis)
+        plot_result = gr.Plot()
+    run_button.click(fn=curve_fit, inputs=[], outputs=[plot_result])
 
 demo.launch()