| import gradio as gr | |
| def greet(name): | |
| return "Hello " + name + "!!" | |
| iface = gr.Interface(fn=greet, inputs="text", outputs="text") | |
| iface.launch() | |
| # # !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." | |
| # if __name__ == "__main__": | |
| # iface.launch() |