Create app.py

app.py

@@ -1,609 +1,7 @@
-# !pip install gradio
-
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-from torch.utils.data import TensorDataset, DataLoader
-import torch.nn as nn
-import torch.optim as optim
-import torch
-# Visualize the simulated data
-import matplotlib.pyplot as plt
-import plotly.graph_objs as go
-import IPython
-import numpy as np
-from graphviz import Digraph
-import copy
-import plotly.graph_objs as go
-import torch
-import numpy as np
-import colorsys
-from functools import partial
-import gradio as gr # may requeire session restart
-import os
-import uuid
-from contextlib import contextmanager
-NETWORK_ORIENTAION = 'h' # 'h' for horizontal 'v' for vertical
-TEMP_DIR = "/content/temp"
-if not os.path.exists(TEMP_DIR):
-    os.makedirs(TEMP_DIR)
-
-"""## functions"""
-
-# @title generate data
-
-def simulate_clusters(noise=0.3,data_points=1000):
-    assert data_points%4==0, 'Data points should be dived by 4'
-    # Set random seed for reproducibility
-    np.random.seed(0)
-
-    # Define means and covariances for the Gaussian distributions
-    means = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
-    covs = [np.eye(2) * noise for _ in means]  # Small covariance for tight clusters
-
-    # Generate samples for each cluster
-    cluster_samples = []
-    for mean, cov in zip(means, covs):
-        samples = np.random.multivariate_normal(mean, cov, data_points//4)
-        cluster_samples.append(samples)
-
-    # Concatenate all samples and create labels
-    X = np.vstack(cluster_samples)
-    y = np.array([i//(data_points//4) for i in range(data_points)])  # Assign labels based on cluster index
-    # Clusters [(-1, -1), (1, 1)] have label 0, and [(-1, 1), (1, -1)] have label 1.
-    y_adjusted = np.array([0 if i in [0, 3] else 1 for i in y])
-
-    # Split the adjusted dataset
-    X_train_adj, X_test_adj, y_train_adj, y_test_adj = train_test_split(X, y_adjusted, test_size=0.2, random_state=42)
-
-    # Normalize the features
-    scaler_adj = StandardScaler()
-    X_train_scaled_adj = scaler_adj.fit_transform(X_train_adj)
-    X_test_scaled_adj = scaler_adj.transform(X_test_adj)
-
-    # Convert to PyTorch tensors
-    X_train_tensor_adj = torch.tensor(X_train_scaled_adj, dtype=torch.float32)
-    y_train_tensor_adj = torch.tensor(y_train_adj, dtype=torch.long)
-    X_test_tensor_adj = torch.tensor(X_test_scaled_adj, dtype=torch.float32)
-    y_test_tensor_adj = torch.tensor(y_test_adj, dtype=torch.long)
-
-    return X_train_tensor_adj,y_train_tensor_adj,X_test_tensor_adj,y_test_tensor_adj
-
-# @title plotting network with activation
-def get_color(activation, base_color=False):
-    if base_color:
-        # Convert base color from hex to RGB
-        r_base, g_base, b_base = int(base_color[1:3], 16), int(base_color[3:5], 16), int(base_color[5:7], 16)
-
-        # Interpolate between the base color and white based on activation
-        r = r_base + (255 - r_base) * (1 - activation)
-        g = g_base + (255 - g_base) * (1 - activation)
-        b = b_base + (255 - b_base) * (1 - activation)
-
-        return f'#{int(r):02x}{int(g):02x}{int(b):02x}'
-
-
-    else:
-        if activation > 0:
-            return f"#0000FF{int(activation * 255):02X}"  # Blue with varying intensity
-        return "#E0E0E0"  # Light gray for inactive neurons
-
-
-rd = lambda activation: ("\n"+"{:.2f}".format(torch.round(activation,decimals=2).item())) if activation!=1 else ''
-#sigmoid = lambda x: 1 / (1 + torch.exp(-x)) if x!=1 else 1
-softmax = lambda x: torch.exp(x) / torch.sum(torch.exp(x), axis=0) if all(x!=1) else x
-
-
-rd = lambda activation: ("\n"+"{:.2f}".format(torch.round(activation,decimals=2).item())) if activation!=1 else ''
-def visualize_network_with_weights(model, activations=False, norm='net', decision_boundary_images=None, width=1, height=1):
-    dot = Digraph()
-    if NETWORK_ORIENTAION=='h':
-        dot.attr(rankdir='LR')
-    pos_color = "blue"
-    neg_color = "orange"
-    layers_weights = {}
-    max_weight = 0
-    number_of_layer = 3
-    # Colors for different layers
-    input_color, hidden_color, output_color1,output_color2 = '#90EE90','#D3D3D3', '#FFB6C1' ,  '#ADD8E6' # light grey, light green,light red, light blue
-
-    # Extract weights for each layer and calculate max weight for normalization
-    for name, layer in model.named_children():
-        if isinstance(layer, torch.nn.Linear):
-            layer_weight = layer.weight.cpu().data.numpy()
-            layers_weights[name] = layer_weight
-            max_weight = max(max_weight, np.abs(layer_weight).max())
-            output_layer_name = name #this evantually save the output layer name
-    # Initialize activations if not provided
-    if not activations:
-        activations = {layer: [1] * weight.shape[0] for layer, weight in layers_weights.items()}
-
-    # Normalize weights for visualization purposes
-    layers_weights_norm = {layer: weight / (np.abs(weight).max() if norm == 'layer' else max_weight)
-                           for layer, weight in layers_weights.items()}
-    def add_node_with_border(node_id, label, base_color, activation, image_path=None, shape='circle', border_color='black', border_width=1):
-        fill_color = get_color(activation, base_color)
-        if image_path:
-            dot.node(node_id, label, shape='box', style='filled', fillcolor=fill_color, color=border_color, penwidth=str(border_width),imagescale='both', width=str(width), height=str(height), image=image_path, fixedsize='true')
-        else:
-            dot.node(node_id, label, shape=shape, style='filled', fillcolor=fill_color, color=border_color, penwidth=str(border_width))
-    axis_names = ['X','Y']
-    # Add nodes and edges...
-    for i in range(layers_weights['fc1'].shape[1]):
-        add_node_with_border(f'h0_{i}' , f'X{i} - {axis_names[i]} Axis', input_color, 1.0)  # Input nodes are always 'active'
-
-    for layer_i in range(1,number_of_layer):
-        layer_name = 'fc'+str(layer_i)
-        for i, activation in enumerate(activations[layer_name]):
-            image_path = decision_boundary_images[layer_name][i] if decision_boundary_images and layer_name in decision_boundary_images and len(decision_boundary_images[layer_name]) > i else None
-            add_node_with_border(f'h{layer_i}_{i}', f'H{layer_i}_{i}{rd(activation)}', hidden_color, activation, image_path=image_path)
-    norm_output_activations  = softmax(torch.tensor([activations[output_layer_name][0],activations[output_layer_name][1]]))
-    activation_label1,activation_label2 = norm_output_activations
-    add_node_with_border(f'h{number_of_layer}_0', f"Y0 - Label 0{rd(activation_label1)}", output_color1, activation_label1,shape='doublecircle')
-    add_node_with_border(f'h{number_of_layer}_1', f"Y1 - Label 1{rd(activation_label2)}", output_color2, activation_label2,shape='doublecircle')
-
-
-    # Adding edges between layers
-    prev_layer_size = layers_weights[list(layers_weights.keys())[0]].shape[1]  # Size of the input layer
-    prev_layer_name = 'h0'
-
-    for layer_idx, (layer_name, weight_matrix) in enumerate(layers_weights.items(), start=1):
-        current_layer_size = weight_matrix.shape[0]
-
-        for i in range(prev_layer_size):
-            for j in range(current_layer_size):
-                color = pos_color if weight_matrix[j, i] >= 0 else neg_color
-                dot.edge(f'{prev_layer_name}_{i}', f'h{layer_idx}_{j}', penwidth=str(abs(layers_weights_norm[layer_name][j, i]) * 5), color=color)
-
-        prev_layer_size = current_layer_size
-        prev_layer_name = f'h{layer_idx}'
-
-    return dot
-
-# @title Plots (learning curve and decision boundary)
-def plot_decision_boundary(model, X_train, y_train, X_test, y_test, show=True, epoch=''):
-    # Set model to evaluation mode
-    model.eval()
-
-    # Set min and max values and give it some padding
-    x_min, x_max = min(X_train[:, 0].min(), X_test[:, 0].min()) - 1, max(X_train[:, 0].max(), X_test[:, 0].max()) + 1
-    y_min, y_max = min(X_train[:, 1].min(), X_test[:, 1].min()) - 1, max(X_train[:, 1].max(), X_test[:, 1].max()) + 1
-    h = 0.01
-
-    # Generate a grid of points with distance h between them
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
-
-    # Flatten the grid so the values match expected input
-    grid = np.c_[xx.ravel(), yy.ravel()]
-    grid_tensor = torch.FloatTensor(grid)
-    with torch.no_grad():
-        predictions = model(grid_tensor.to(model.device)).argmax(1).to('cpu')
-    Z = predictions.numpy().reshape(xx.shape)
-
-    # Create the contour plot
-    contour = go.Contour(
-        x=np.arange(x_min, x_max, h),
-        y=np.arange(y_min, y_max, h),
-        z=Z,
-        colorscale='RdYlBu',  # Light colors for background
-        showscale=False  # Hide the colorbar
-    )
-
-    # Separate data based on labels
-    train_0 = X_train[y_train == 0]
-    train_1 = X_train[y_train == 1]
-    test_0 = X_test[y_test == 0]
-    test_1 = X_test[y_test == 1]
-
-    # Create scatter plots for each category
-    train_0_scatter = go.Scatter(x=train_0[:, 0], y=train_0[:, 1], mode='markers',
-                                 marker=dict(color='red', line=dict(color='black', width=1)),
-                                 name='Train - Label 0')
-    train_1_scatter = go.Scatter(x=train_1[:, 0], y=train_1[:, 1], mode='markers',
-                                 marker=dict(color='green', line=dict(color='black', width=1)),
-                                 name='Train - Label 1')
-    test_0_scatter = go.Scatter(x=test_0[:, 0], y=test_0[:, 1], mode='markers',
-                                marker=dict(color='rgba(255, 200, 200, 1)', symbol='circle-open', line=dict(color='black', width=1)),
-                                name='Test - Label 0')
-    test_1_scatter = go.Scatter(x=test_1[:, 0], y=test_1[:, 1], mode='markers',
-                                marker=dict(color='rgba(200, 255, 200, 1)', symbol='circle-open', line=dict(color='black', width=1)),
-                                name='Test - Label 1')
-
-    # Define the layout
-    layout = go.Layout(
-        title='Decision Boundary ' + epoch,
-        xaxis=dict(title='Feature 1'),
-        yaxis=dict(title='Feature 2'),
-        showlegend=True
-    )
-    # Create the figure and add the contour and scatter plots
-    fig = go.Figure(data=[contour, train_0_scatter, train_1_scatter, test_0_scatter, test_1_scatter], layout=layout)
-
-    # Show the plot
-    if show: fig.show()
-    return fig
-
-
-def generate_learning_curve(loss_hist, loss_val_hist, hidden_units, noise, epochs, lr,metric):
-    with torch.no_grad():
-        metric = 'Loss' if metric.lower()=='loss' else "Accuracy"
-        # Create traces for the training and validation loss
-        trace_train = go.Scatter(
-            x=list(range(1, epochs + 1)),
-            y=loss_hist,
-            mode='lines',
-            name=f'Training {metric}'
-        )
-        trace_val = go.Scatter(
-            x=list(range(1, epochs + 1)),
-            y=loss_val_hist,
-            mode='lines',
-            name=f'Validation {metric}'
-        )
-
-        # Combine traces
-        data = [trace_train, trace_val]
-
-        # Layout for the plot
-        layout = go.Layout(
-            title=f'Learning Curve - Hidden Units: {hidden_units}, Noise: {noise}, Learning Rate: {lr}',
-            xaxis=dict(title='Epochs'),
-            yaxis=dict(title=metric),
-
-        )
-
-    # Create the figure and show it
-    fig = go.Figure(data=data, layout=layout)
-    return fig
-
-def save_plot_as_image(fig, remove_axes=True, remove_title=True, remove_colorbar=True, transparent_background=True):
-    """
-    Saves a Matplotlib figure as an image and returns the path to the image.
-    Args:
-    fig (matplotlib.figure.Figure): The Matplotlib figure to save.
-    remove_axes (bool): If True, removes the axes from the plot.
-    remove_title (bool): If True, removes the title and header from the plot.
-    remove_colorbar (bool): If True, removes the colorbar from the plot.
-    transparent_background (bool): If True, saves the image with a transparent background.
-    Returns:
-    str: Path to the saved image file.
-    """
-    # Check if fig is a valid Matplotlib figure
-    if not isinstance(fig, plt.Figure):
-        raise ValueError("The provided object is not a Matplotlib figure.")
-
-    # Remove axes if requested
-    if remove_axes:
-        for ax in fig.axes:
-            ax.get_xaxis().set_visible(False)
-            ax.get_yaxis().set_visible(False)
-            ax.set_frame_on(False)
-
-    # Remove title and header if requested
-    if remove_title:
-        fig.suptitle("")
-        for ax in fig.axes:
-            ax.title.set_visible(False)
-
-    # Remove colorbar if requested
-    if remove_colorbar:
-        for ax in fig.axes:
-            if hasattr(ax, 'collections') and ax.collections:
-                # Check for the presence of a colorbar in this axis
-                for im in ax.get_images():
-                    if hasattr(im, 'colorbar') and im.colorbar:
-                        im.colorbar.remove()
-
-    # Set transparent background if requested
-    if transparent_background:
-        fig.patch.set_alpha(0)
-        for ax in fig.axes:
-            ax.patch.set_alpha(0)
-
-
-    # Generate a unique filename for the image
-    filename = f"plot_{uuid.uuid4()}.png"
-    file_path = os.path.join(TEMP_DIR, filename)
-
-    # Save the figure with a transparent background if requested
-    fig.savefig(file_path, bbox_inches='tight', pad_inches=0, transparent=transparent_background)
-
-    return file_path
-
-def plot_neuron_decision_boundaries(model, X, step=0.01):
-    # Ensure X is a NumPy array
-    if isinstance(X, torch.Tensor):
-        X = X.cpu().numpy()
-    mesh_border_expansion = 0.5 # the mesh is calculted between the highest and lowest values in each axis, with `mesh_border_expansion` additional space
-    # Generate mesh grid for decision boundaries
-    x_min, x_max = X[:, 0].min() - mesh_border_expansion , X[:, 0].max() + mesh_border_expansion
-    y_min, y_max = X[:, 1].min() - mesh_border_expansion , X[:, 1].max() + mesh_border_expansion
-    xx, yy = np.meshgrid(np.arange(x_min, x_max, step), np.arange(y_min, y_max, step))
-    mesh_inputs = torch.Tensor(np.c_[xx.ravel(), yy.ravel()])
-
-    model.eval()
-    figures_dict = {}
-    layer_outputs = mesh_inputs
-    with torch.no_grad():
-        for name, layer in model.named_children():
-            # Apply the layer
-            layer_outputs = layer(layer_outputs.to(model.device))
-
-            # Check if the layer is ReLU or the last layer
-            if isinstance(layer, nn.Linear) or (name == list(model.named_children())[-1][0]):
-                # Convert to NumPy for plotting
-                outputs_np = layer_outputs.cpu().numpy()
-                for neuron_idx in range(outputs_np.shape[1]):
-                    Z = outputs_np[:, neuron_idx].reshape(xx.shape)
-
-                    Z_min, Z_max = Z.min(), Z.max()
-                    levels = sorted([Z_min, 0, Z_max]) if Z_min < 0 < Z_max else [Z_min, Z_max]
-
-                    fig, ax = plt.subplots()
-                    # ax.contourf(xx, yy, Z, levels=np.linspace(Z.min(), Z.max(), 200), cmap=plt.cm.RdBu, alpha=0.8)
-                    ax.contourf(xx, yy, Z, levels=levels, cmap=plt.cm.RdBu, alpha=0.8)
-                    # ax.set_title(f"Decision boundary of Neuron {neuron_idx+1} in {name}")
-                    # ax.set_xlabel('Feature 1')
-                    # ax.set_ylabel('Feature 2')
-                    plt.show()
-                    plt.close(fig)
-                    if name not in figures_dict:
-                        figures_dict[name]=[]
-                    figures_dict[name] += [fig]
-
-    return figures_dict
-
-
-# plot_neuron_decision_boundaries(  fc_model, X_train)
-
-# step=0.01
-# x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1
-# y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1
-# xx, yy = np.meshgrid(np.arange(x_min, x_max, step), np.arange(y_min, y_max, step))
-# mesh_inputs = torch.Tensor(np.c_[xx.ravel(), yy.ravel()])
-# mesh_inputs
-
-# @title network architecture and training
-
-# Global variables to hold model and data
-global fc_model_hist, X_train, y_train, X_test, y_test
-fc_model_hist, X_train, y_train, X_test, y_test = None, None, None, None, None
-
-class FCNet(nn.Module):
-    def __init__(self,hidden_units,device):
-        super(FCNet, self).__init__()
-        self.fc1 = nn.Linear(2, hidden_units)  # Input layer with 2 features
-        self.act_func1 = nn.ReLU() # it is important to declare on each relu layer, becuase some of the plotting functions uses model.named_layers() and the ReLU won't be there without explicit declration here
-        self.fc2 = nn.Linear(hidden_units, hidden_units)
-        self.act_func2 = nn.ReLU()
-        self.fc3 = nn.Linear(hidden_units, 2)  # Output layer with 2 neurons (for 2 classes)
-        self.device = device
-    def forward(self, x):
-        x = self.act_func1(self.fc1(x))
-        x = self.act_func2(self.fc2(x))
-        x = self.fc3(x)
-        return x
-    def forward_with_activation(self, x):
-        inputs = x
-        x1 = self.act_func1(self.fc1(x))
-        x2 = self.act_func2(self.fc2(x1))
-        x3 = self.fc3(x2)
-        return x,{'inputs':inputs,'fc1':x1,'fc2':x2,'fc3':x3}
-    def to(self, device):
-        super().to(device)
-        self.device = device
-        return self
-
-def init_net_and_train(hidden_units = 4,noise = 0.2,epochs = 30,data_points = 1000,lr=0.01,device='cpu',metric='acc'):
-    global fc_model_hist, X_train, y_train, X_test, y_test
-    # Simulate the dataset
-    X_train,y_train,X_test,y_test = simulate_clusters(noise,data_points)
-
-    # Create TensorDataset and DataLoader
-    train_dataset_adj = TensorDataset(X_train, y_train)
-    train_loader_adj = DataLoader(train_dataset_adj, batch_size=64, shuffle=True)
-    test_dataset_adj = TensorDataset(X_test, y_test)
-    test_loader_adj = DataLoader(test_dataset_adj, batch_size=64, shuffle=True)
-    # Define a simple Fully Connected network with fewer neurons
-    # Initialize the simple fully connected neural network
-    fc_model = FCNet(hidden_units,device=device)
-    fc_model.to(device)
-    # Loss and optimizer for the  FC network
-    fc_criterion = nn.CrossEntropyLoss()
-    fc_optimizer = optim.Adam(fc_model.parameters(), lr=lr)
-
-    # Training loop for the simple FC network
-    fc_model_hist = []
-
-    # loss_hist = []
-    # loss_val_hist = []
-
-    # for epoch in range(epochs):
-    #     cur_epoch_loss=torch.tensor(0.,device=fc_model.device)
-    #     inputs_len = 0
-    #     for inputs, labels in train_loader_adj:
-    #         # Forward pass
-    #         outputs = fc_model(inputs.to(device))
-    #         loss = fc_criterion(outputs, labels.to(device))
-    #         cur_epoch_loss+=loss
-    #         inputs_len += labels.shape[0]
-    #         # Backward and optimize
-    #         fc_optimizer.zero_grad()
-    #         loss.backward()
-    #         fc_optimizer.step()
-    #     train_loss = cur_epoch_loss.cpu()/inputs_len
-    #     loss_hist.append(train_loss)
-    #     fc_model_hist.append(copy.deepcopy(fc_model).to('cpu'))
-    #     with torch.no_grad():
-    #         cur_epoch_loss=torch.tensor(0.,device=device)
-    #         inputs_len = 0
-    #         for inputs, labels in test_loader_adj:
-    #             outputs = fc_model(inputs.to(device))
-    #             loss = fc_criterion(outputs, labels.to(device))
-    #             cur_epoch_loss+=loss
-    #             inputs_len += labels.shape[0]
-    #         test_loss = cur_epoch_loss.cpu()/inputs_len
-    #         loss_val_hist.append(test_loss)
-
-    loss_hist = []
-    loss_val_hist = []
-    acc_hist = []
-    acc_val_hist = []
-
-    device = fc_model.device
-
-    for epoch in range(epochs):
-        fc_model.train()  # Set model to training mode
-        cur_epoch_loss = 0
-        correct_train = 0
-        total_train = 0
-
-        for inputs, labels in train_loader_adj:
-            inputs, labels = inputs.to(device), labels.to(device)
-            fc_optimizer.zero_grad()
-            outputs = fc_model(inputs)
-            loss = fc_criterion(outputs, labels)
-            loss.backward()
-            fc_optimizer.step()
-
-            cur_epoch_loss += loss.item() * inputs.size(0)
-            _, predicted = torch.max(outputs.data, 1)
-            total_train += labels.size(0)
-            correct_train += (predicted == labels).sum().item()
-
-        train_loss = cur_epoch_loss / total_train
-        train_accuracy = correct_train / total_train
-        loss_hist.append(train_loss)
-        acc_hist.append(train_accuracy)
-
-        fc_model.eval()  # Set model to evaluation mode for validation
-        fc_model_hist.append(copy.deepcopy(fc_model).to('cpu'))
-        cur_epoch_loss = 0
-        correct_test = 0
-        total_test = 0
-
-        with torch.no_grad():
-            for inputs, labels in test_loader_adj:
-                inputs, labels = inputs.to(device), labels.to(device)
-                outputs = fc_model(inputs)
-                loss = fc_criterion(outputs, labels)
-
-                cur_epoch_loss += loss.item() * inputs.size(0)
-                _, predicted = torch.max(outputs.data, 1)
-                total_test += labels.size(0)
-                correct_test += (predicted == labels).sum().item()
-
-        test_loss = cur_epoch_loss / total_test
-        test_accuracy = correct_test / total_test
-        loss_val_hist.append(test_loss)
-        acc_val_hist.append(test_accuracy)
-
-
-        # print(f'Epoch [{epoch+1}/{epochs}], Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}')
-
-    # return fc_model,fc_model_hist,loss_hist,X_train,y_train,X_test,y_test
-    if metric=='acc':
-        reported_metric_train,reported_metric_val = acc_hist,acc_val_hist
-    else:
-        reported_metric_train,reported_metric_val = loss_hist,loss_val_hist
-    return generate_learning_curve(reported_metric_train,reported_metric_val,hidden_units,noise,epochs,lr,metric)
-
-# @title functions for retriving app images
-def get_network_with_inputs(epoch, input_x, input_y,output_type = "HTML"):
-    if epoch>len(fc_model_hist):
-        epoch = len(fc_model_hist)
-    with torch.no_grad():
-        cur_model = fc_model_hist[epoch - 1]
-        out, activations = cur_model.forward_with_activation(torch.tensor([input_x, input_y], dtype=torch.float32,device=cur_model.device))
-        network_dot = visualize_network_with_weights(cur_model, activations=activations)
-    if output_type=='PNG':
-        cur_path = f'network_with_weights_activation_{epoch}'
-        network_dot.render(cur_path, format='png', cleanup=True)
-        return cur_path + ".png"
-    else:
-        svg_content = network_dot.pipe(format='svg').decode('utf-8')
-        # Create HTML content embedding the SVG
-        html_content = f'<div style="width:100%; height:100%;">{svg_content}</div>'
-        return html_content
-
-
-get_plots_as_png = lambda des_list: [save_plot_as_image(plot) for plot in des_list]
-
-
-as_HTML=False
-
-def generate_images(epoch,net_with_unit_decisions=True):
-    global fc_model_hist
-    if epoch>len(fc_model_hist):
-        epoch = len(fc_model_hist)
-    fig = plot_decision_boundary(fc_model_hist[epoch-1], X_train, y_train, X_test, y_test, show=False,epoch=f'Epoch:{epoch}')
-    # network_html = network_dot_paths_list[epoch]
-    if not net_with_unit_decisions:
-        network_dot = visualize_network_with_weights(fc_model_hist[epoch-1])
-    else:
-        decision_plots = plot_neuron_decision_boundaries(fc_model_hist[epoch-1], X_train)
-        decision_boundary_images = {k:get_plots_as_png(decision_plots[k]) for k in decision_plots}
-        network_dot = visualize_network_with_weights(fc_model_hist[epoch-1], activations=False, decision_boundary_images=decision_boundary_images)
-    if as_HTML:
-        svg_content = network_dot.pipe(format='svg').decode('utf-8')
-        network_proccessed = f'<div style="width:100%; height:100%;">{svg_content}</div>'
-    else:
-        cur_path = f'{TEMP_DIR}/network_with_weights_activation_{epoch}'
-        network_dot.render(cur_path, format='png', cleanup=True)
-        network_proccessed = cur_path+".png"
-
-    return fig, network_proccessed
-
-@contextmanager
-def dummy_context():
-    yield
-
 import gradio as gr
-"""## Launch the app"""
-
-device ='cuda' if torch.cuda.is_available() else 'cpu'
-init_net_and_train_part = partial(init_net_and_train,device=device)
-
-with gr.Blocks() as iface:
-
-    tab_train = gr.Tab("Network Training")
-    tab_viz = gr.Tab("Network Visualization")
-
-    with tab_train:
-            hidden_units_slider = gr.Slider(minimum=1, maximum=10, step=1, value=4, label="number of neurons in hidden layer")
-            noise_slider = gr.Slider(minimum=0.001, maximum=0.7, step=0.01, value=0.2, label="Noise")
-            epochs_slider = gr.Slider(minimum=1, maximum=50, step=1, value=30, label="Epochs")
-            lr_slider = gr.Slider(minimum=0.001, maximum=0.05, step=0.001, value=0.008, label="Learning Rate")
-            data_points_slider = gr.Slider(minimum=100, maximum=2000, step=4, value=1000, label="Data Points")
-            train_button = gr.Button("Train Network")
-            learning_curve = gr.Plot(label="Learning Curve")
-
-    with tab_viz:
-            with (gr.Row() if NETWORK_ORIENTAION != 'h' else dummy_context()):
-                with (gr.Column() if NETWORK_ORIENTAION != 'h' else dummy_context()):
-                    with (gr.Row() if NETWORK_ORIENTAION != 'v' else dummy_context()):
-                        epoch_viz_slider = gr.Slider(minimum=1, maximum=50, step=1, value=1, label="Visualize Epoch")  # Dynamic update needed here
-                        ner_bounds = gr.Checkbox(label="Invidual neurons decision boundaries")
-                        generate_button = gr.Button("Visualize Network")
-                    plot_output = gr.Plot(label="Decision Boundary")
-                    overall_net_output = gr.Image(type="filepath",label="Network Visualization")
-                with (gr.Column() if NETWORK_ORIENTAION != 'h' else dummy_context()):
-                    with gr.Row():
-                        input_x = gr.Number(label="Input X")
-                        input_y = gr.Number(label="Input Y")
-                        update_button = gr.Button("Check Input")
-                    net_activity_sample_output = gr.HTML(label="Network Activity for an Input")
-                    # net_activity_sample_output = gr.Image(type="filepath", label="Network Activity for an Input")
-
-    # Set up button click actions
-    train_button.click(fn=init_net_and_train, inputs=[hidden_units_slider, noise_slider, epochs_slider, data_points_slider, lr_slider], outputs=learning_curve)
-    generate_button.click(fn=generate_images, inputs=[epoch_viz_slider,ner_bounds], outputs=[plot_output, overall_net_output])
-    update_button.click(fn=get_network_with_inputs, inputs=[epoch_viz_slider, input_x, input_y], outputs=net_activity_sample_output)
-
-    # # Add Tabs to the interface
-    # iface.add_tabs(tab_train, tab_viz)
 
-iface.title = "Neural Network Visualization"
-iface.description = "Adjust parameters and train the network to see its performance and visualization."
+def greet(name):
+    return "Hello " + name + "!!"
 
-if __name__ == "__main__":
-    iface.launch()
+iface = gr.Interface(fn=greet, inputs="text", outputs="text")
+iface.launch()