files

bagging_classifier_viz.py

@@ -0,0 +1,89 @@
+import matplotlib.pyplot as plt
+import streamlit as st
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.datasets import make_moons
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+from sklearn.ensemble import BaggingClassifier
+from sklearn.metrics import accuracy_score
+
+# Generate data
+X, y = make_moons(n_samples=500, noise=0.30, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+# Function to draw meshgrid for decision boundary visualization
+def draw_meshgrid():
+    a = np.arange(start=X[:, 0].min() - 1, stop=X[:, 0].max() + 1, step=0.01)
+    b = np.arange(start=X[:, 1].min() - 1, stop=X[:, 1].max() + 1, step=0.01)
+    XX, YY = np.meshgrid(a, b)
+    input_array = np.array([XX.ravel(), YY.ravel()]).T
+    return XX, YY, input_array
+
+plt.style.use('seaborn-v0_8-bright')
+
+st.sidebar.markdown("# Bagging Classifier")
+
+# Sidebar inputs
+estimators = st.sidebar.selectbox(
+    'Select base estimator',
+    ('Decision Tree', 'KNN', 'SVM')
+)
+
+n_estimators = int(st.sidebar.number_input('Enter number of estimators', min_value=1, value=10))
+max_samples = st.sidebar.slider('Max Samples', 1, 375, 375, step=25)
+bootstrap_samples = st.sidebar.radio("Bootstrap Samples", ('True', 'False')) == 'True'
+max_features = st.sidebar.slider('Max Features', 1, 2, 2, key=1234)
+bootstrap_features = st.sidebar.radio("Bootstrap Features", ('False', 'True'), key=2345) == 'True'
+
+# Load initial graph
+fig, ax = plt.subplots()
+ax.scatter(X.T[0], X.T[1], c=y, cmap='rainbow')
+orig = st.pyplot(fig)
+
+if st.sidebar.button('Run Algorithm'):
+    if estimators == "Decision Tree":
+        estimator = DecisionTreeClassifier()
+    elif estimators == "KNN":
+        estimator = KNeighborsClassifier()
+    else:
+        estimator = SVC()
+
+    clf = estimator.fit(X_train, y_train)
+    y_pred_tree = clf.predict(X_test)
+
+    bag_clf = BaggingClassifier(
+        estimator=estimator,
+        n_estimators=n_estimators,
+        max_samples=max_samples,
+        bootstrap=bootstrap_samples,
+        max_features=max_features,
+        bootstrap_features=bootstrap_features,
+        random_state=42
+    )
+    bag_clf.fit(X_train, y_train)
+    y_pred = bag_clf.predict(X_test)
+
+    orig.empty()
+
+    fig, ax = plt.subplots()
+    fig1, ax1 = plt.subplots()
+
+    XX, YY, input_array = draw_meshgrid()
+    labels = clf.predict(input_array)
+    labels1 = bag_clf.predict(input_array)
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.header(estimators)
+        ax.scatter(X.T[0], X.T[1], c=y, cmap='rainbow')
+        ax.contourf(XX, YY, labels.reshape(XX.shape), alpha=0.5, cmap='rainbow')
+        orig = st.pyplot(fig)
+        st.subheader(f"Accuracy for {estimators}: {round(accuracy_score(y_test, y_pred_tree), 2)}")
+    with col2:
+        st.header("Bagging Classifier")
+        ax1.scatter(X.T[0], X.T[1], c=y, cmap='rainbow')
+        ax1.contourf(XX, YY, labels1.reshape(XX.shape), alpha=0.5, cmap='rainbow')
+        orig1 = st.pyplot(fig1)
+        st.subheader(f"Accuracy for Bagging: {round(accuracy_score(y_test, y_pred), 2)}")

bagging_regressor_viz.py

@@ -0,0 +1,96 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import streamlit as st
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.ensemble import BaggingRegressor
+from sklearn.svm import SVR
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.metrics import r2_score
+
+plt.style.use('seaborn-v0_8-bright')
+
+n_train = 150
+n_test = 100
+noise = 0.1
+
+np.random.seed(0)
+
+# Generate data
+def f(x):
+    x = x.ravel()
+    return np.exp(-x ** 2) + 1.5 * np.exp(-(x - 2) ** 2)
+
+def generate(n_samples, noise):
+    X = np.random.rand(n_samples) * 10 - 5
+    X = np.sort(X).ravel()
+    y = np.exp(-X ** 2) + 1.5 * np.exp(-(X - 2) ** 2) + np.random.normal(0.0, noise, n_samples)
+    X = X.reshape((n_samples, 1))
+    return X, y
+
+X_train, y_train = generate(n_samples=n_train, noise=noise)
+X_test, y_test = generate(n_samples=n_test, noise=noise)
+
+st.sidebar.markdown("# Bagging Regressor")
+
+estimator = st.sidebar.selectbox(
+    'Select base estimator',
+    ('Decision Tree', 'SVM', 'KNN')
+)
+
+n_estimators = int(st.sidebar.number_input('Enter number of estimators', min_value=1, value=10))
+
+max_samples = st.sidebar.slider('Max Samples', 1, n_train, n_train, step=25)
+
+bootstrap_samples = st.sidebar.radio(
+    "Bootstrap Samples",
+    ('True', 'False')
+) == 'True'  # Convert string to boolean
+
+# Load initial graph
+fig, ax = plt.subplots()
+
+# Plot initial graph
+ax.scatter(X_train, y_train, color="yellow", edgecolor="black")
+orig = st.pyplot(fig)
+
+if st.sidebar.button('Run Algorithm'):
+
+    if estimator == 'Decision Tree':
+        algo = DecisionTreeRegressor()
+    elif estimator == 'SVM':
+        algo = SVR()
+    else:
+        algo = KNeighborsRegressor()
+
+    reg = algo.fit(X_train, y_train)
+
+    bag_reg = BaggingRegressor(
+        estimator=algo,  # Updated parameter name
+        n_estimators=n_estimators,
+        max_samples=max_samples,
+        bootstrap=bootstrap_samples
+    ).fit(X_train, y_train)
+    
+    bag_reg_predict = bag_reg.predict(X_test)
+    reg_predict = reg.predict(X_test)
+
+    # R2 scores
+    bag_r2 = r2_score(y_test, bag_reg_predict)
+    reg_r2 = r2_score(y_test, reg_predict)
+
+    orig.empty()
+
+    fig, ax = plt.subplots()
+    fig1, ax1 = plt.subplots()
+
+    st.subheader(f"Bagging - {estimator} (R2 score - {bag_r2:.2f})")
+    ax1.scatter(X_train, y_train, color="yellow", edgecolor="black")
+    ax1.plot(X_test, bag_reg_predict, linewidth=1, label="Bagging")
+    ax1.legend()
+    st.pyplot(fig1)
+
+    st.subheader(f"{estimator} (R2 score - {reg_r2:.2f})")
+    ax.scatter(X_train, y_train, color="yellow", edgecolor="black")
+    ax.plot(X_test, reg_predict, linewidth=1, color='red', label=estimator)
+    ax.legend()
+    st.pyplot(fig)

decision_tree_steps.py

@@ -0,0 +1,85 @@
+import matplotlib.pyplot as plt
+import streamlit as st
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.datasets import make_moons
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+from sklearn.tree import plot_tree
+from sklearn.tree import export_graphviz
+from os import system
+from graphviz import Source
+from sklearn import tree
+
+def draw_meshgrid():
+    a = np.arange(start=X[:, 0].min() - 1, stop=X[:, 0].max() + 1, step=0.01)
+    b = np.arange(start=X[:, 1].min() - 1, stop=X[:, 1].max() + 1, step=0.01)
+
+    XX, YY = np.meshgrid(a, b)
+
+    input_array = np.array([XX.ravel(), YY.ravel()]).T
+
+    return XX, YY, input_array
+
+X, y = make_moons(n_samples=500, noise=0.30, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+plt.style.use('fivethirtyeight')
+
+st.sidebar.markdown("# Decision Tree Classifier")
+
+criterion = st.sidebar.selectbox(
+    'Criterion',
+    ('gini', 'entropy')
+)
+
+splitter = st.sidebar.selectbox(
+    'Splitter',
+    ('best', 'random')
+)
+
+max_depth = int(st.sidebar.number_input('Max Depth'))
+
+min_samples_split = st.sidebar.slider('Min Samples Split', 1, X_train.shape[0], 2,key=1234)
+
+min_samples_leaf = st.sidebar.slider('Min Samples Leaf', 1, X_train.shape[0], 1,key=1235)
+
+max_features = st.sidebar.slider('Max Features', 1, 2, 2,key=1236)
+
+max_leaf_nodes = int(st.sidebar.number_input('Max Leaf Nodes'))
+
+min_impurity_decrease = st.sidebar.number_input('Min Impurity Decrease')
+
+# Load initial graph
+fig, ax = plt.subplots()
+
+# Plot initial graph
+ax.scatter(X.T[0], X.T[1], c=y, cmap='rainbow')
+orig = st.pyplot(fig)
+
+if st.sidebar.button('Run Algorithm'):
+
+    orig.empty()
+
+    if max_depth == 0:
+        max_depth = None
+
+    if max_leaf_nodes == 0:
+        max_leaf_nodes = None
+
+    clf = DecisionTreeClassifier(criterion=criterion,splitter=splitter,max_depth=max_depth,random_state=42,min_samples_split=min_samples_split,min_samples_leaf=min_samples_leaf,max_features=max_features,max_leaf_nodes=max_leaf_nodes,min_impurity_decrease=min_impurity_decrease)
+    clf.fit(X_train, y_train)
+    y_pred = clf.predict(X_test)
+
+    XX, YY, input_array = draw_meshgrid()
+    labels = clf.predict(input_array)
+
+    ax.contourf(XX, YY, labels.reshape(XX.shape), alpha=0.5, cmap='rainbow')
+    plt.xlabel("Col1")
+    plt.ylabel("Col2")
+    orig = st.pyplot(fig)
+    st.subheader("Accuracy for Decision Tree  " + str(round(accuracy_score(y_test, y_pred), 2)))
+
+    tree = export_graphviz(clf,feature_names=["Col1","Col2"])
+
+    st.graphviz_chart(tree)

gd_sgd_app.py

@@ -0,0 +1,251 @@
+import streamlit as st
+import numpy as np
+import plotly.graph_objs as go
+
+def convex_function(x, y):
+    return x**2 + y**2
+
+def non_convex_function(x, y):
+    return np.sin(x) * np.cos(y) * x * y
+
+def gradient_descent(func, grad_func, start, learning_rate, n_iter):
+    path = [start]
+    for _ in range(n_iter):
+        grad = grad_func(path[-1])
+        next_point = path[-1] - learning_rate * grad
+        path.append(next_point)
+    return np.array(path)
+
+def stochastic_gradient_descent(func, grad_func, start, learning_rate, n_iter):
+    path = [start]
+    for _ in range(n_iter):
+        grad = grad_func(path[-1]) + np.random.normal(0, 0.1, 2)
+        next_point = path[-1] - learning_rate * grad
+        path.append(next_point)
+    return np.array(path)
+
+def grad_convex(point):
+    x, y = point
+    return np.array([2*x, 2*y])
+
+def grad_non_convex(point):
+    x, y = point
+    return np.array([np.cos(x) * np.cos(y) * y + np.sin(x) * np.sin(y) * x, np.cos(x) * np.cos(y) * x - np.sin(x) * np.sin(y) * y])
+
+def simulated_annealing(func, start, temp, cooling_rate, n_iter):
+    path = [start]
+    current_point = start
+    lowest_point = current_point
+    for i in range(n_iter):
+        next_point = current_point + np.random.normal(0, 1, 2)
+        delta_E = func(next_point[0], next_point[1]) - func(current_point[0], current_point[1])
+        if delta_E < 0 or np.exp(-delta_E / temp) > np.random.rand():
+            current_point = next_point
+        if func(current_point[0], current_point[1]) < func(lowest_point[0], lowest_point[1]):
+            lowest_point = current_point
+        path.append(current_point)
+        temp *= cooling_rate
+    return np.array(path), lowest_point
+
+def plot_3d_surface(func, path, title, alphas=None, lowest_point=None):
+    x_min, x_max = min(path[:, 0].min(), -6), max(path[:, 0].max(), 6)
+    y_min, y_max = min(path[:, 1].min(), -6), max(path[:, 1].max(), 6)
+    
+    x = np.linspace(x_min, x_max, 200)
+    y = np.linspace(y_min, y_max, 200)
+    X, Y = np.meshgrid(x, y)
+    Z = func(X, Y)
+
+    fig = go.Figure(data=[go.Surface(z=Z, x=X, y=Y, opacity=0.7)])
+    if alphas is None:
+        alphas = [1.0] * len(path)
+    
+    for i in range(len(path) - 1):
+        fig.add_trace(go.Scatter3d(
+            x=path[i:i+2, 0],
+            y=path[i:i+2, 1],
+            z=func(path[i:i+2, 0], path[i:i+2, 1]),
+            mode='lines',
+            line=dict(color='orange', width=4),
+            opacity=alphas[i],
+            showlegend=False
+        ))
+    fig.add_trace(go.Scatter3d(
+        x=path[:, 0],
+        y=path[:, 1],
+        z=func(path[:, 0], path[:, 1]),
+        mode='markers',
+        marker=dict(size=4, color='orange', opacity=alphas[-1]),
+        name='Path'
+    ))
+    fig.add_trace(go.Scatter3d(
+        x=[path[0, 0]],
+        y=[path[0, 1]],
+        z=[func(path[0, 0], path[0, 1])],
+        mode='markers',
+        marker=dict(size=6, color='green', opacity=alphas[0]),
+        name='Start'
+    ))
+    
+    if lowest_point is not None:
+        fig.add_trace(go.Scatter3d(
+            x=[lowest_point[0]],
+            y=[lowest_point[1]],
+            z=[func(lowest_point[0], lowest_point[1])],
+            mode='markers',
+            marker=dict(size=6, color='red', opacity=alphas[-1]),
+            name='Lowest Observed'
+        ))
+    
+    fig.update_layout(title=title, scene=dict(
+                        xaxis_title='X',
+                        yaxis_title='Y',
+                        zaxis_title='Z'))
+    return fig
+
+st.title("Convex and Non-Convex SGD Optimization")
+
+
+tab1, tab2, tab3 = st.tabs(["Gradient Descent", "Stochastic Gradient Descent", "Simulated Annealing"])
+
+st.sidebar.header("Parameters")
+
+learning_rate = st.sidebar.slider("Learning Rate", 0.01, 1.0, 0.1)
+n_iter = st.sidebar.slider("Number of Iterations", 10, 100, 50)
+convex_start_x = st.sidebar.slider("Convex Start X", -3.0, 3.0, 2.5)
+convex_start_y = st.sidebar.slider("Convex Start Y", -3.0, 3.0, 2.5)
+non_convex_start_x = st.sidebar.slider("Non-Convex Start X", -3.0, 3.0, 2.5)
+non_convex_start_y = st.sidebar.slider("Non-Convex Start Y", -3.0, 3.0, 2.5)
+temp = st.sidebar.slider("Initial Temperature (Simulated Annealing)", 1.0, 10.0, 5.0)
+cooling_rate = st.sidebar.slider("Cooling Rate (Simulated Annealing)", 0.8, 0.99, 0.95)
+
+convex_start = np.array([convex_start_x, convex_start_y])
+non_convex_start = np.array([non_convex_start_x, non_convex_start_y])
+
+with tab1:
+    st.header("Gradient Descent")
+    st.write("Visualizing gradient descent on convex and non-convex functions.")
+
+    with st.expander("Gradient Descent Algorithm and Math"):
+        st.markdown(r"""
+        ### Gradient Descent Algorithm
+        **Step-by-step Algorithm**:
+        1. Initialize starting point $\mathbf{x}_0$.
+        2. For each iteration $t$:
+           - Compute the gradient $\nabla f(\mathbf{x}_t)$.
+           - Update the current point: $\mathbf{x}_{t+1} = \mathbf{x}_t - \alpha \nabla f(\mathbf{x}_t)$.
+        **Mathematical Formulation**:
+        $$
+        \mathbf{x}_{t+1} = \mathbf{x}_t - \alpha \nabla f(\mathbf{x}_t)
+        $$
+        where:
+        - $\mathbf{x}_t$ is the current point.
+        - $\alpha$ is the learning rate.
+        - $\nabla f(\mathbf{x}_t)$ is the gradient of the function at $\mathbf{x}_t$.
+        """)
+
+    convex_path_gd = gradient_descent(convex_function, grad_convex, convex_start, learning_rate, n_iter)
+    non_convex_path_gd = gradient_descent(non_convex_function, grad_non_convex, non_convex_start, learning_rate, n_iter)
+
+    st.plotly_chart(plot_3d_surface(convex_function, convex_path_gd, "Convex Function (GD)"))
+    st.plotly_chart(plot_3d_surface(non_convex_function, non_convex_path_gd, "Non-Convex Function (GD)"))
+
+with tab2:
+    st.header("Stochastic Gradient Descent")
+    st.write("Visualizing stochastic gradient descent on convex and non-convex functions.")
+
+    with st.expander("Stochastic Gradient Descent Algorithm and Math"):
+        st.markdown(r"""
+        ### Stochastic Gradient Descent Algorithm
+        **Step-by-step Algorithm**:
+        1. Initialize starting point $\mathbf{x}_0$.
+        2. For each iteration $t$:
+           - Compute a stochastic approximation of the gradient $\nabla f(\mathbf{x}_t) + \text{noise}$.
+           - Update the current point: $\mathbf{x}_{t+1} = \mathbf{x}_t - \alpha \left(\nabla f(\mathbf{x}_t) + \text{noise}\right)$.
+        **Mathematical Formulation**:
+        $$
+        \mathbf{x}_{t+1} = \mathbf{x}_t - \alpha \left(\nabla f(\mathbf{x}_t) + \text{noise}\right)
+        $$
+        where:
+        - $\mathbf{x}_t$ is the current point.
+        - $\alpha$ is the learning rate.
+        - $\nabla f(\mathbf{x}_t)$ is the gradient of the function at $\mathbf{x}_t$.
+        - $\text{noise}$ is a small random perturbation.
+        """)
+
+    convex_path_sgd = stochastic_gradient_descent(convex_function, grad_convex, convex_start, learning_rate, n_iter)
+    non_convex_path_sgd = stochastic_gradient_descent(non_convex_function, grad_non_convex, non_convex_start, learning_rate, n_iter)
+
+    st.plotly_chart(plot_3d_surface(convex_function, convex_path_sgd, "Convex Function (SGD)"))
+    st.plotly_chart(plot_3d_surface(non_convex_function, non_convex_path_sgd, "Non-Convex Function (SGD)"))
+
+with tab3:
+    st.header("Simulated Annealing")
+    st.write("Visualizing simulated annealing on a non-convex function.")
+
+    with st.expander("Simulated Annealing Algorithm and Math"):
+        st.markdown(r"""
+        ### Simulated Annealing Algorithm
+        **Step-by-step Algorithm**:
+        1. Initialize starting point $\mathbf{x}_0$ and temperature $T$.
+        2. For each iteration $t$:
+           - Generate a new point $\mathbf{x}'$ in the neighborhood of the current point $\mathbf{x}_t$.
+           - Compute the change in function value $\Delta E = f(\mathbf{x}') - f(\mathbf{x}_t)$.
+           - If $\Delta E < 0$, accept the new point $\mathbf{x}_{t+1} = \mathbf{x}'$.
+           - If $\Delta E \geq 0$, accept the new point with a probability $\exp\left(\frac{-\Delta E}{T}\right)$.
+           - Update the temperature $T$.
+        **Mathematical Formulation**:
+        $$
+        \mathbf{x}_{t+1} =
+        \begin{cases} 
+        \mathbf{x}' & \text{if } \Delta E < 0 \\
+        \mathbf{x}' & \text{with probability } \exp\left(\frac{-\Delta E}{T}\right) \text{ if } \Delta E \geq 0 \\
+        \mathbf{x}_t & \text{otherwise}
+        \end{cases}
+        $$
+        where:
+        - $\mathbf{x}_t$ is the current point.
+        - $\mathbf{x}'$ is the new point.
+        - $T$ is the temperature.
+        - $\Delta E = f(\mathbf{x}') - f(\mathbf{x}_t)$ is the change in function value.
+        - $\exp\left(\frac{-\Delta E}{T}\right)$ is the acceptance probability.
+        """)
+
+    non_convex_path_sa, lowest_point = simulated_annealing(non_convex_function, non_convex_start, temp, cooling_rate, n_iter)
+
+    # Visualizing the path with alpha changing based on iteration
+    alphas = np.linspace(0.1, 1, len(non_convex_path_sa))
+    fig_sa = plot_3d_surface(non_convex_function, non_convex_path_sa, "Non-Convex Function (SA)", alphas=alphas, lowest_point=lowest_point)
+    
+    # Adding blue points for other iteration's observed minimums
+    other_mins = non_convex_path_sa[:-1]
+    fig_sa.add_trace(go.Scatter3d(
+        x=other_mins[:, 0],
+        y=other_mins[:, 1],
+        z=non_convex_function(other_mins[:, 0], other_mins[:, 1]),
+        mode='markers',
+        marker=dict(size=4, color='blue'),
+        name='Observed Minima'
+    ))
+    
+    # Adding the final minimum point in red
+    fig_sa.add_trace(go.Scatter3d(
+        x=[lowest_point[0]],
+        y=[lowest_point[1]],
+        z=[non_convex_function(lowest_point[0], lowest_point[1])],
+        mode='markers',
+        marker=dict(size=6, color='red'),
+        name='Lowest Observed'
+    ))
+    
+    # Adding the starting point in green
+    fig_sa.add_trace(go.Scatter3d(
+        x=[non_convex_path_sa[0, 0]],
+        y=[non_convex_path_sa[0, 1]],
+        z=[non_convex_function(non_convex_path_sa[0, 0], non_convex_path_sa[0, 1])],
+        mode='markers',
+        marker=dict(size=6, color='green'),
+        name='Start'
+    ))
+
+    st.plotly_chart(fig_sa)

voting_classifier_viz.py

@@ -0,0 +1,74 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+from sthelper import StHelper
+import data_helper
+
+# Import all datasets
+concentric, linear, outlier, spiral, ushape, xor = data_helper.load_dataset()
+
+# Configure matplotlib styling
+plt.style.use('seaborn-v0_8-bright')
+
+# Dataset selection dropdown
+st.sidebar.markdown("# Voting Classifier")
+dataset = st.sidebar.selectbox(
+    "Dataset",
+    ("U-Shaped", "Linearly Separable", "Outlier", "Two Spirals", "Concentric Circles", "XOR")
+)
+
+# Estimator multi-select
+estimators = st.sidebar.multiselect(
+    'Estimators',
+    [
+        'KNN',
+        'Logistic Regression',
+        'Gaussian Naive Bayes',
+        'SVM',
+        'Random Forest'
+    ]
+)
+
+# Voting type radio button
+voting_type = st.sidebar.radio(
+    "Voting Type",
+    (
+        'hard',
+        'soft',
+    )
+)
+
+st.header(dataset)
+fig, ax = plt.subplots()
+
+# Plot initial graph
+df = data_helper.load_initial_graph(dataset, ax)
+orig = st.pyplot(fig)
+
+# Extract X and Y
+X = df.iloc[:, :2].values
+y = df.iloc[:, -1].values
+
+# Create sthelper object
+sthelper = StHelper(X, y)
+
+# On button click
+if st.sidebar.button("Run Algorithm"):
+    algos = sthelper.create_base_estimators(estimators, voting_type)
+    voting_clf, voting_clf_accuracy = sthelper.train_voting_classifier(algos, voting_type)
+    sthelper.draw_main_graph(voting_clf, ax)
+    orig.pyplot(fig)
+    figs = sthelper.plot_other_graphs(algos)
+    
+    # Plot accuracies
+    st.sidebar.header("Classification Metrics")
+    st.sidebar.text("Voting Classifier accuracy: " + str(voting_clf_accuracy))
+    accuracies = sthelper.calculate_base_model_accuracy(algos)
+    for i in range(len(accuracies)):
+        st.sidebar.text("Accuracy for Model " + str(i + 1) + " - " + str(accuracies[i]))
+
+    counter = 0
+    for i in st.columns(len(figs)):
+        with i:
+            st.pyplot(figs[counter])
+            st.text(counter)
+        counter += 1

voting_regressor_viz.py

@@ -0,0 +1,99 @@
+import matplotlib.pyplot as plt
+import streamlit as st
+from sklearn.linear_model import LinearRegression
+from sklearn.svm import SVR
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.ensemble import VotingRegressor
+from sklearn.model_selection import train_test_split
+import numpy as np
+from sklearn.metrics import r2_score,mean_absolute_error
+
+def train_voting_regressor(algos):
+
+    vr = VotingRegressor(algos)
+    vr.fit(X_train,y_train)
+
+    y_pred = vr.predict(X_test1)
+
+    r2 = r2_score(y_test1,y_pred)
+    mae = mean_absolute_error(y_test1,y_pred)
+
+    return vr,r2,mae
+
+plt.style.use('seaborn-bright')
+
+# Create a random dataset
+rng = np.random.RandomState(1)
+X = np.sort(5 * rng.rand(80, 1), axis=0)
+y = np.sin(X).ravel()
+y[::5] += 3 * (0.5 - rng.rand(16))
+
+# Random state - 8
+X_train,X_test1,y_train,y_test1 = train_test_split(X,y,test_size=0.1,random_state=8)
+
+# Predict
+X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
+
+
+st.sidebar.markdown("# Voting Regressor")
+
+# Estimator Multi-select
+estimators = st.sidebar.multiselect(
+    'Estimators',
+    [
+        'Linear Regression',
+        'SVR',
+        'Decision Tree Regressor'
+    ]
+)
+
+# Build estimators
+algos = []
+
+if 'Linear Regression' in estimators:
+    lr_reg = LinearRegression()
+    algos.append(('lr', lr_reg))
+if 'SVR' in estimators:
+    svr_reg = SVR()
+    algos.append(('svr', svr_reg))
+if 'Decision Tree Regressor' in estimators:
+    dt_reg = DecisionTreeRegressor(max_depth=5)
+    algos.append(('dt', dt_reg))
+
+fig, ax = plt.subplots()
+ax.scatter(X, y, s=100,color="yellow", edgecolor="black")
+orig = st.pyplot(fig)
+
+
+if st.sidebar.button("Run Algorithm"):
+    vr,r2,mae = train_voting_regressor(algos)
+    y_2 = vr.predict(X_test)
+    ax.plot(X_test, y_2, linewidth=3,label="Voting Regressor")
+    ax.legend()
+    orig.pyplot(fig)
+    figs = []
+    r2_scores = []
+    maes = []
+    for i in algos:
+        i[1].fit(X_train,y_train)
+        y_pred = i[1].predict(X_test)
+        y_pred1 = i[1].predict(X_test1)
+        r2_scores.append(r2_score(y_test1,y_pred1))
+        maes.append(mean_absolute_error(y_test1,y_pred1))
+        ax.plot(X_test, y_pred, linewidth=1,label=i[0],linestyle='dashdot')
+        ax.legend()
+
+    counter = 0
+    for i in st.beta_columns(len(algos)):
+        with i:
+            orig.pyplot(fig)
+        counter += 1
+
+    st.sidebar.subheader("Regression Metrics")
+    st.sidebar.text("R2 score Voting Regressor " + str(round(r2,2)))
+    st.sidebar.text("MAE Voting Regressor " + str(round(mae,2)))
+
+    for i in range(len(algos)):
+        st.sidebar.text("*"*35)
+        st.sidebar.text("R2 score for " + algos[i][0] + " " + str(round(r2_scores[i],2)))
+        st.sidebar.text("MAE score for " + algos[i][0] + " " + str(round(maes[i], 2)))