Create New File

app.py

@@ -0,0 +1,289 @@
+from sklearn import datasets, ensemble
+from sklearn.inspection import permutation_importance
+from sklearn.metrics import mean_squared_error
+from sklearn.model_selection import train_test_split
+import plotly.graph_objs as go
+import numpy as np
+import plotly.express as px
+import pandas as pd
+
+
+import gradio as gr
+
+
+diabetes = datasets.load_diabetes(as_frame=True)
+X, y = diabetes.data, diabetes.target
+
+
+def display_table(row_number):
+    X, y = diabetes.data, diabetes.target
+    XX = pd.concat([X, y], axis=1)
+    temp_df = XX[row_number : row_number + 15]
+    Statement = f"Displayed Rows From Row Number {row_number} to {row_number+15}"
+    return Statement, temp_df
+
+
+def train_model(
+    test_split,
+    learning_rate,
+    n_estimators,
+    max_depth,
+    min_samples_split,
+    loss,
+    duration,
+):
+    X, y = diabetes.data, diabetes.target
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_split, random_state=42
+    )
+    params = {
+        "n_estimators": n_estimators,
+        "max_depth": max_depth,
+        "min_samples_split": min_samples_split,
+        "learning_rate": learning_rate,
+        "loss": loss,
+    }
+    global reg
+    reg = ensemble.GradientBoostingRegressor(**params)
+    reg.fit(X_train, y_train)
+
+    mse = mean_squared_error(y_test, reg.predict(X_test))
+
+    x = np.arange(params["n_estimators"]) + 1
+    train_score = reg.train_score_
+    test_score = np.zeros((params["n_estimators"],), dtype=np.float64)
+    for i, y_pred in enumerate(reg.staged_predict(X_test)):
+        test_score[i] = mean_squared_error(y_test, y_pred)
+
+    test_score = test_score
+
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Scatter(
+            x=x,
+            y=train_score,
+            mode="lines",
+            name="Training Set Deviance",
+            line=dict(color="blue"),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=x,
+            y=test_score,
+            mode="lines",
+            name="Test Set Deviance",
+            line=dict(color="red"),
+        )
+    )
+
+    frames = [
+        go.Frame(
+            data=[
+                go.Scatter(
+                    x=x[: k + 1],
+                    y=train_score[: k + 1],
+                    mode="lines",
+                    line=dict(color="blue"),
+                ),
+                go.Scatter(
+                    x=x[: k + 1],
+                    y=test_score[: k + 1],
+                    mode="lines",
+                    line=dict(color="red"),
+                ),
+            ],
+            name=f"frame{k}",
+        )
+        for k in range(1, len(x))
+    ]
+
+    fig.frames = frames
+
+    fig.update_layout(
+        title="Deviance",
+        xaxis_title="Boosting Iterations",
+        yaxis_title="Deviance",
+        legend=dict(x=0, y=1),
+        updatemenus=[
+            dict(
+                type="buttons",
+                showactive=False,
+                direction="right",
+                pad={"r": 10},
+                buttons=[
+                    dict(
+                        label="Play",
+                        method="animate",
+                        args=[
+                            None,
+                            dict(
+                                frame=dict(duration=duration, redraw=True),
+                                fromcurrent=True,
+                                transition=dict(duration=0),
+                            ),
+                        ],
+                    ),
+                    dict(
+                        label="Pause",
+                        method="animate",
+                        args=[
+                            [None],
+                            dict(
+                                frame=dict(duration=0, redraw=False),
+                                mode="immediate",
+                                transition=dict(duration=0),
+                            ),
+                        ],
+                    ),
+                ],
+                x=0.5,
+                y=-0.2,
+            )
+        ],
+    )
+
+    return fig, mse
+
+
+def Plot_featue_importance(test_split):
+    try:
+        feature_importance = reg.feature_importances_
+    except:
+        # return blank figures
+        fig = go.Figure()
+        fig.update_layout(title="Train Your Model to See Plots")
+        return fig, fig
+
+    sorted_idx = np.argsort(feature_importance)
+
+    fig = px.bar(
+        pd.DataFrame(
+            {
+                "Importance": feature_importance[sorted_idx],
+                "Feature": np.array(diabetes.feature_names)[sorted_idx],
+            }
+        ),
+        x="Importance",
+        y="Feature",
+        orientation="h",
+        title="Feature Importance (MDI)",
+    )
+
+    X, y = diabetes.data, diabetes.target
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_split, random_state=42
+    )
+    result = permutation_importance(
+        reg, X_test, y_test, n_repeats=10, random_state=42, n_jobs=2
+    )
+
+    fig1 = px.box(
+        pd.DataFrame(result.importances.T, columns=diabetes.feature_names),
+        title="Permutation Importance (test set)",
+    )
+
+    return fig, fig1
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Gradient Boosting regression")
+    gr.Markdown(
+        "Demo is Based on [Gradient Boosting regression](https://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_regression.html) Example.This example demonstrates Gradient Boosting to produce a predictive model from an ensemble of weak predictive models. Gradient boosting can be used for regression and classification problems. Here, we will train a model to tackle a diabetes regression task."
+    )
+
+    with gr.Tab("Data"):
+        gr.Markdown("## Below is the Diabetes Dataset used in this Demo")
+        gr.Markdown("### Feel free to change the number of rows to display")
+        gr.Markdown(
+            "The diabetes dataset consists of ten baseline variables, age, sex, body mass index (BMI), average blood pressure (BP), and six blood serum measurements for 442 diabetes patients. The target variable is a quantitative measure of disease progression one year after baseline."
+        )
+        total_rows = X.shape[0]
+        rows_number = gr.Slider(
+            0, total_rows, label="Displaying Rows", value=15, step=15
+        )
+
+        rows_number.change(
+            fn=display_table,
+            inputs=[rows_number],
+            outputs=[gr.Text(label="Rows Information"), gr.DataFrame()],
+        )
+
+    with gr.Tab("Trian Your Model"):
+        gr.Markdown(
+            "# Play with the parameters to see how the model Performance changes"
+        )
+
+        gr.Markdown(
+            """
+        ### `Number of Estimators` : the number of boosting stages that will be performed. Later, we will plot deviance against boosting iterations.
+
+        ### `Max Depth` : limits the number of nodes in the tree. The best value depends on the interaction of the input variables.
+
+        ### `Min Samples Split` : the minimum number of samples required to split an internal node.
+
+        ### `learning_rate` : how much the contribution of each tree will shrink.
+
+        ### `loss` : loss function to optimize.
+
+        ### `Test Split` : the percentage of the dataset to include in the test split.
+
+        ### `Animation Speed for Deviance Plot` : the duration of the animation of Deviation Plot.
+        """
+        )
+        with gr.Row():
+            test_split = gr.Slider(0.1, 0.9, label="Test Split", value=0.2, step=0.1)
+            learning_rate = gr.Slider(
+                0.01, 0.5, label="Learning Rate", value=0.1, step=0.01
+            )
+            n_estimators = gr.Slider(
+                10, 1000, label="Number of Estimators", value=100, step=10
+            )
+            max_depth = gr.Slider(1, 10, label="Max Depth", value=3, step=1)
+            min_samples_split = gr.Slider(
+                2, 10, label="Min Samples Split", value=2, step=1
+            )
+            loss = gr.Dropdown(
+                ["squared_error", "absolute_error", "huber", "quantile"],
+                label="Loss",
+                value="squared_error",
+            )
+
+            duration = gr.Slider(
+                0, 100, label="Animation Speed for Deviance Plot", value=25, step=10
+            )
+
+        model_btn = gr.Button("Train Model")
+        gr.Markdown(
+            "### Finally, we will visualize the results. To do that we will first compute the test set deviance and then plot it against boosting iterations."
+        )
+        model_btn.click(
+            fn=train_model,
+            inputs=[
+                test_split,
+                learning_rate,
+                n_estimators,
+                max_depth,
+                min_samples_split,
+                loss,
+                duration,
+            ],
+            outputs=[gr.Plot(), gr.Text(label="MSE")],
+        )
+
+    with gr.Tab("Feature Importance"):
+        gr.Markdown("## Feature Importance (MDI) and Permutation Importance (test set)")
+        gr.Markdown(
+            "For this example, the impurity-based and permutation methods identify the same 2 strongly predictive features but not in the same order. The third most predictive feature, “bp”, is also the same for the 2 methods. The remaining features are less predictive and the error bars of the permutation plot show that they overlap with 0."
+        )
+        feat_imp_btn = gr.Button("Plot Feature Importance")
+        with gr.Row():
+            feat_imp_btn.click(
+                fn=Plot_featue_importance,
+                inputs=[test_split],
+                outputs=[gr.Plot(), gr.Plot()],
+            )
+
+
+demo.launch()