Update app.py

app.py

@@ -1,3 +1,14 @@
+
+"""
+========================================
+Plot multi-class SGD on the iris dataset
+========================================
+
+Plot decision surface of multi-class SGD on iris dataset.
+The hyperplanes corresponding to the three one-versus-all (OVA) classifiers
+are represented by the dashed lines.
+
+"""
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
@@ -5,37 +16,30 @@ from sklearn import datasets
 from sklearn.linear_model import SGDClassifier
 from sklearn.inspection import DecisionBoundaryDisplay
 
-def predict_class(x, y):
-    iris = datasets.load_iris()
-    X = iris.data[:, :2]
-    y = iris.target
-    colors = "bry"
-    idx = np.arange(X.shape[0])
-    np.random.seed(13)
-    np.random.shuffle(idx)
-    X = X[idx]
-    y = y[idx]
-    mean = X.mean(axis=0)
-    std = X.std(axis=0)
-    X = (X - mean) / std
-    clf = SGDClassifier(alpha=0.001, max_iter=100).fit(X, y)
-    predicted_class = clf.predict(np.array([[x, y]]))[0]
-    return iris.target_names[predicted_class]
 
-def decision_boundary(x_min, x_max, y_min, y_max):
+def plot(alpha):
+# import some data to play with
     iris = datasets.load_iris()
+
+# we only take the first two features. We could
+# avoid this ugly slicing by using a two-dim dataset
     X = iris.data[:, :2]
     y = iris.target
     colors = "bry"
+
+# shuffle
     idx = np.arange(X.shape[0])
     np.random.seed(13)
     np.random.shuffle(idx)
     X = X[idx]
     y = y[idx]
+
+# standardize
     mean = X.mean(axis=0)
     std = X.std(axis=0)
     X = (X - mean) / std
-    clf = SGDClassifier(alpha=0.001, max_iter=100).fit(X, y)
+
+    clf = SGDClassifier(alpha=alpha, max_iter=100).fit(X, y)
     ax = plt.gca()
     DecisionBoundaryDisplay.from_estimator(
         clf,
@@ -46,54 +50,49 @@ def decision_boundary(x_min, x_max, y_min, y_max):
         xlabel=iris.feature_names[0],
         ylabel=iris.feature_names[1],
     )
-    plt.axis([x_min, x_max, y_min, y_max])
-    plt.xticks(fontsize=8)
-    plt.yticks(fontsize=8)
-    plt.gcf().set_size_inches(5, 4)
-    return plt.gcf()
-
-iris = datasets.load_iris()
-
-inputs = [
-    gr.inputs.Slider(0, 8, label=iris.feature_names[0], default=5.8, decimal=1),
-    gr.inputs.Slider(0, 8, label=iris.feature_names[1], default=3.5, decimal=1),
-]
-
-output = gr.outputs.Label(num_top_classes=1)
-
-title = "Iris Dataset - Decision Boundary"
-description = "Predict the class of the given data point and show the decision boundary of the SGD classifier."
-article = "<p><a href='https://scikit-learn.org/stable/auto_examples/linear_model/plot_sgd_iris.html'>More about the dataset and the example</a></p>"
-examples = [
-    [
-        5.8,
-        3.5,
-    ],
-    [
-        7.2,
-        3.2,
-    ],
-    [
-        5.1,
-        2.5,
-    ],
-    [
-        4.9,
-        3.1,
-    ],
-]
-
-gr.Interface(
-    predict_class,
-    inputs,
-    output,
-    title=title,
-    description=description,
-    examples=examples,
-    theme=theme,
-    article=article,
-    layout="vertical",
-    allow_flagging=False,
-    live=True,
-    outputs=[None, decision_boundary],
-).launch()
+    plt.axis("tight")
+
+# Plot also the training points
+    for i, color in zip(clf.classes_, colors):
+        idx = np.where(y == i)
+        plt.scatter(
+            X[idx, 0],
+            X[idx, 1],
+            c=color,
+            label=iris.target_names[i],
+            cmap=plt.cm.Paired,
+            edgecolor="black",
+            s=20,
+        )
+    plt.title("Decision surface of multi-class SGD")
+    plt.axis("tight")
+
+# Plot the three one-against-all classifiers
+    xmin, xmax = plt.xlim()
+    ymin, ymax = plt.ylim()
+    coef = clf.coef_
+    intercept = clf.intercept_
+
+
+    def plot_hyperplane(c, color):
+        def line(x0):
+            return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]
+
+        plt.plot([xmin, xmax], [line(xmin), line(xmax)], ls="--", color=color)
+    
+    for i, color in zip(clf.classes_, colors):
+        plot_hyperplane(i, color)
+    plt.legend()
+    #plt.show()
+    return plt
+
+#pl = plot(0)
+#pl.show()
+with gr.Blocks() as demo:
+    alpha = gr.Slider(minimum=0.0001, maximum=10, step=0.01, value=0.0001, label="Alpha Value")
+    with gr.Row():
+        plt = gr.Plot()
+
+    alpha.change(fn=plot, inputs=[alpha],outputs=[plt])
+
+demo.launch()