Upload 6 files

README.md

@@ -1,13 +1,6 @@
 ---
-title: Nano AutoGrad
-emoji: 📊
-colorFrom: red
-colorTo: indigo
+title: Nano-AutoGrad
+app_file: app.py
 sdk: gradio
 sdk_version: 3.35.2
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,50 @@
+import gradio as gr
+from demo import * 
+
+
+
+article = """
+<p style='text-align: center'>
+    <a href='https://github.com/deep-matter/Nano-AutoGrad' target='_blank'>Github Repo Nano-AutoGrad</a>
+</p>
+"""
+
+iface_webcam = gr.Interface(
+    Optimization_training_progress_realtime,
+    inputs=[
+        gr.Radio(["Sparsity"], label="Task"),
+        gr.Slider(minimum=1, maximum=100, label="Number of Epochs"),
+        gr.Slider(minimum=0.01, maximum=1.0, label="Learning Rate"),
+        gr.Number(label="Number of Layers"),
+        gr.Number(label="Values for Weights")
+        # gr.inputs.Slider(minimum=6, maximum=18, step=6, default=12),  # Leaving manual fps out for now
+    ],
+    outputs=[gr.Plot(),gr.Video(),gr.Video()],
+    title="Optimization Training Progress",
+    description="Real-time visualization of training progress",
+    article=article,
+    allow_flagging=False,
+)
+
+iface_file = gr.Interface(
+    Optimization_training_progress_realtime,
+    inputs=[
+        gr.Radio(["Classification"], label="Task"),
+        gr.Slider(minimum=1, maximum=100, label="Number of Epochs"),
+        gr.Slider(minimum=0.01, maximum=1.0, label="Learning Rate"),
+        gr.Number(label="Number of Layers"),
+        gr.Number(label="Values for Weights")
+    ],
+    outputs=[gr.Plot(),gr.Video(),gr.Video()],
+    title="Optimization Training Progress",
+    description="Real-time visualization of training progress",
+    article=article,
+    allow_flagging=False,
+)
+
+if __name__ == '__main__':
+    gr.TabbedInterface(
+        interface_list=[iface_file, iface_webcam],
+        tab_names=["Classification Task", "Sparsity Task"]
+        
+    ).launch(enable_queue=True,share=True)

demo.py

@@ -0,0 +1,246 @@
+from init import *
+import random
+import numpy as np
+from autograd.core.engine import Value
+from autograd.core.nn import Neuron, Layer, MLP
+from autograd.core.Graph import draw_dot
+import time 
+from graphviz import Digraph
+import imageio
+from functools import partial
+import matplotlib.animation as animation
+import shutil
+from IPython.display import HTML
+import os
+import pandas as pd
+import plotly.subplots as sp
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation ,FFMpegWriter
+import matplotlib.pyplot as plt
+from uilit import *
+os.environ["PATH"] += os.pathsep + './dev/lib/Python 3.11/site-packages/graphviz'
+
+path_data = 'digit-recognizer/data/'
+
+
+
+# loss function
+def loss(model,X_train , y_train , batch_size=None):
+    
+    # inline DataLoader :)
+    if batch_size is None:
+        Xb, yb = X_train, y_train
+    else:
+        ri = np.random.permutation(X_train.shape[0])[:batch_size]
+        Xb, yb = X_train[ri], y_train[ri]
+
+    inputs = [list(map(Value, xrow)) for xrow in Xb]
+    
+    # forward the model to get scores
+    scores = list(map(model, inputs))
+    
+    # svm "max-margin" loss
+    losses = [(1 + -yi*scorei).relu() for yi, scorei in zip(yb, scores)]
+    data_loss = sum(losses) * (1.0 / len(losses))
+    # L2 regularization
+    alpha = 0.05 
+    reg_loss = alpha * sum((p*p for p in model.parameters()))
+    total_loss = data_loss + reg_loss
+    
+    # also get accuracy
+    accuracy = [(yi > 0) == (scorei.data > 0) for yi, scorei in zip(yb, scores)]
+    return total_loss, sum(accuracy) / len(accuracy) ,scores
+
+def Optimization_training_progress_realtime(Task,num_epoch, learning_rate ,num_layer,values_wieghts):
+    filename = f"assets/plot_res_{num_epoch-1}.png"
+    filename_ = f"assets/graph_wights_update_{num_epoch-1}.png"
+    if os.path.exists(filename) or os.path.exists(filename_):
+        shutil.rmtree('assets/')
+        os.makedirs('assets/')
+    # Create empty lists for loss and accuracy
+    loss_data = []
+    accuracy_data = []
+    model = MLP(int(num_layer), [int(values_wieghts),int(values_wieghts),1]) # 2-layer neural network
+    # Create subplots with shared x-axis
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, subplot_titles=("Loss", "Accuracy"))
+
+    # Initialize empty lists for loss and accuracy
+    loss_data = []
+    accuracy_data = []
+
+    # Create initial empty traces
+    loss_trace = go.Scatter(x=[], y=[], mode="lines", name="Loss")
+    accuracy_trace = go.Scatter(x=[], y=[], mode="lines", name="Accuracy")
+
+    # Add initial traces to the subplots
+    fig.add_trace(loss_trace, row=1, col=1)
+    fig.add_trace(accuracy_trace, row=2, col=1)
+     # Update layout
+    fig.update_layout(
+        title="Training Progress",
+        xaxis_title="Epoch",
+        yaxis=dict(title="Loss"),
+        yaxis2=dict(title="Accuracy"),
+        showlegend=False,
+        hovermode='x',
+        height=500,
+        width=500,
+        template='plotly_white'
+    )
+    # Define animation frames
+    frames = []
+    if Task in "Sparsity":
+        X_train , Y_train = initialize_data(n_samples=100 ,noise=0.1)
+        
+    elif Task in "Classification":
+        FILES , _  = extract_path_df(path_data,10)
+        X_train, X_test, Y_train, Y_test = loading_df_to_numpy(FILES[0])
+    for k in range(int(num_epoch)):
+        # Forward pass
+        total_loss, acc,scores = loss(model, X_train, Y_train, batch_size=None)
+
+        # Backward pass
+        model.zero_grad()
+        total_loss.backward()
+        draw_dot(model(scores),f'graph_wights_update_{k}')
+
+        # Update (SGD)
+
+        learning_rate = 1.0 - 0.9 * k / 100
+
+        for p in model.parameters():
+            p.data -= learning_rate * p.grad 
+
+        if k % 2 == 0:
+            print(f"step {k} loss {total_loss.data}, accuracy {acc*100}%")
+   
+        # Append data to lists
+        loss_data.append(total_loss.data)
+        accuracy_data.append(acc)
+
+         # Update traces
+        with fig.batch_update():
+            fig.data[0].x = list(range(k+1))
+            fig.data[0].y = loss_data
+            fig.data[1].x = list(range(k+1))
+            fig.data[1].y = accuracy_data
+
+        # Append current frame to frames list
+        frames.append(go.Frame(data=[fig.data[0], fig.data[1]]))
+
+        if Task in "Sparsity":
+            h = 0.25
+            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, h),
+                                np.arange(y_min, y_max, h))
+
+            Xmesh = np.c_[xx.ravel(), yy.ravel()]
+            inputs = [list(map(Value, xrow)) for xrow in Xmesh]
+            scores = list(map(model, inputs))
+            Z = np.array([s.data > 0 for s in scores])
+            Z = Z.reshape(xx.shape)
+
+            plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
+            plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train, s=40, cmap=plt.cm.Spectral)
+            plt.xlim(xx.min(), xx.max())
+            plt.ylim(yy.min(), yy.max())
+            plt.savefig(f'assets/plot_res_{k}.png')
+     # Add frames to animation
+    fig.frames = frames
+    nframes = int(num_epoch)
+    interval = int(num_epoch) * 2
+
+    # Create animation
+    animation = go.Figure(fig)
+
+    # Set animation settings
+    animation.update_layout(
+        updatemenus=[
+            {
+                "buttons": [
+                    {
+                        "args": [None, {"frame": {"duration": 500, "redraw": True},
+                                        "fromcurrent": True, "transition": {"duration": 0}}],
+                        "label": "Play",
+                        "method": "animate"
+                    }
+                ],
+                "showactive": False,
+                "type": "buttons"
+            }
+        ]
+    )
+
+    # Display animation
+    # Save animation as GIF
+        
+    if Task in "Sparsity":
+        graph_trace("graph_wights_update", nframes,interval)
+        fig_2 = plt.figure()
+        def animate_predicion(i):
+            im1 = plt.imread(f"assets/plot_res_{i}.png")
+            plt.imshow(im1)
+            plt.title(f"Epoch: {i+1}\nLoss: {loss_data[i]:.4f} - Accuracy: {accuracy_data[i]:.4f}")
+            plt.xlabel("prediction")
+            plt.axis('off')
+
+            fig_2.tight_layout()
+
+        lin_ani = FuncAnimation(fig_2, animate_predicion, frames=nframes, interval=200)
+        FFwriter = FFMpegWriter(fps=10)
+
+        lin_ani.save('out/training.mp4', writer=FFwriter)
+        # Display the animation
+     # Show the figure
+        return animation ,'out/training.mp4', 'out/Graph.mp4'
+
+    if Task in "Classification":
+        graph_trace("graph_wights_update", nframes,interval)
+        inputs_test = [list(map(Value, xrow)) for xrow in X_test]
+        predictions = [scorei.data.argmax() for scorei in list(map(model, inputs_test))]
+
+        # Plot a few examples
+        num_examples = 8
+        fig_1, axes = plt.subplots(2, 2, figsize=(12, 6))
+        fig_1.subplots_adjust(hspace=0.4, wspace=0.4)
+
+        def animate(i):
+            for j, ax in enumerate(axes.flatten()):
+                if j < num_examples:
+                    random_index = random.randint(0, X_test.shape[1] - 1)
+                    ax.imshow(X_test[:, random_index, None].reshape(28, 28), cmap="gray")
+                    ax.set_title(f"Predicted: {Y_test[random_index]}")
+                    ax.axis('off')
+                else:
+                    ax.axis('off')
+
+        fig_1.tight_layout()
+
+        lin_ani = FuncAnimation(fig_1, animate, frames=nframes, interval=200)
+        FFwriter = FFMpegWriter(fps=10)
+
+        lin_ani.save('out/Predicted.mp4', writer=FFwriter)
+        # fig_1.savefig("reulst.png")
+        return animation , 'out/Predicted.mp4', 'out/Graph.mp4'
+
+
+
+
+   
+
+if __name__ == "__main__":
+
+    np.random.seed(1337)
+    random.seed(1337)
+    models = Optimization_training_progress_realtime(
+        Task="Sparsity",num_epoch=5, learning_rate=0.002 ,
+        num_layer=2,values_wieghts=4)
+
+    
+
+    
+

init.py

@@ -0,0 +1,5 @@
+import os 
+import sys
+# Add the parent directory of app.py to the system path
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(parent_dir)

requirements.txt

@@ -0,0 +1,16 @@
+pandas
+plotly
+numpy 
+matplotlib
+random2
+scipy 
+scikit-learn
+kaleido
+ipython
+nbformat>=4.2.0
+ipywidgets>=7.0.0
+imageio
+graphviz
+gradio
+nano-autograds
+sphinx

uilit.py

@@ -0,0 +1,135 @@
+from init import *
+import numpy as np 
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
+from PIL import Image
+
+import matplotlib.animation as animation
+from matplotlib.animation import FuncAnimation
+from IPython.display import clear_output
+from autograd.core.engine import Value
+from sklearn.datasets import make_moons, make_blobs
+import plotly.graph_objects as go
+import plotly.io as pio
+import imageio
+
+clear_output()
+
+# Iterate through the first 6 images
+
+def extract_path_df(path_dir, index_show):
+    path_file = []
+
+    for filesname in os.listdir(path_dir):
+        path_file.append(os.path.join(path_dir,filesname))
+
+    for data_df in range(0,len(path_file)):
+        data_frame = pd.read_csv(path_file[data_df])
+        show_df = data_frame.head(index_show)
+    return path_file , f"dataframe: {show_df}"
+
+def loading_df_to_numpy(path_file):
+    data_df = pd.read_csv(path_file)
+    data = np.array(data_df) 
+    m, n = data.shape
+    data_train = data[1000:m].T
+    Y_train = data_train[0][40900:]
+    X_train = data_train[1:n][:, 40900:]
+
+
+    # Manually split the data into training and testing sets
+    split_index = int(X_train.shape[0] * 0.8)  # 80% for training, 20% for testing
+    X_train_split = X_train[:, :10]
+    Y_train_split = Y_train[:10]
+    X_test_split = X_train[:,:5]
+    Y_test_split = Y_train[:5]
+
+    return X_train_split, X_test_split, Y_train_split, Y_test_split
+
+def initialize_data(n_samples: int, noise: float):
+    input_data, Target = make_moons(n_samples=n_samples, noise=noise)
+
+    Target = Target * 2 - 1  # make y be -1 or 14
+    # fig.close()
+    return input_data, Target
+
+
+def plot_sample(DATA_TRAIN,DATA_LABEL):
+    num_images = min(6, DATA_TRAIN.shape[1])
+    fig, axs = plt.subplots(2, 3, figsize=(10, 7))
+
+    for i in range(num_images):
+        label = DATA_LABEL
+        image = DATA_TRAIN[:, i]
+        current_image = image.reshape(28, 28) * 255
+
+        # Determine the subplot coordinates
+        row = i // 3
+        col = i % 3
+
+    # Plot the image in the corresponding subplot
+        axs[row, col].imshow(current_image, cmap='gray')
+        axs[row, col].set_title("Label: {}".format(label))
+        axs[row, col].axis('off')
+
+    plt.tight_layout()
+    plt.savefig("sample.png")
+
+def copy(model):
+  model = SparseMLP(nin=2, nouts=[16, 16, 1], sparsities=[0.,0.9,0.8])
+  model.parameters()
+  return model
+
+def Zvals(model , X_train):
+  global X
+  h = 0.25
+  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, h),
+                      np.arange(y_min, y_max, h))
+  Xmesh = np.c_[xx.ravel(), yy.ravel()]
+  inputs = [list(map(Value, xrow)) for xrow in Xmesh]
+  scores = list(map(model, inputs))
+  Z = np.array([s.data > 0 for s in scores])
+  Z = Z.reshape(xx.shape)
+  return Z
+
+
+def dboundary(model):
+  global X
+  global Y
+  h = 0.25
+  x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
+  y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
+  xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
+                      np.arange(y_min, y_max, h))
+  Xmesh = np.c_[xx.ravel(), yy.ravel()]
+  fig, ax = plt.subplots(figsize=(8,8))
+  Z = Zvals(model)
+  ln = ax.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
+  ax.scatter(X[:, 0], X[:, 1], c=Y, s=40, cmap=plt.cm.Spectral)
+  ax.set_xlim(xx.min(), xx.max())
+  ax.set_ylim(yy.min(), yy.max())
+  return  fig,ax,ln
+
+def graph_trace(Path, nframes, interval):
+    animation_frames = []
+    # Load the first image to get its dimensions and color mode
+    first_frame_path = f"assets/{Path}_0.png"
+    first_image = Image.open(first_frame_path)
+    width, height = first_image.size
+    color_mode = first_image.mode
+
+    # Resize and convert all the images to the same dimensions and color mode
+    resized_width = 900  # Set your desired width
+    resized_height = 700  # Set your desired height
+
+    for i in range(nframes):
+        frame_path = f"assets/{Path}_{i}.png"
+        image = Image.open(frame_path)
+        resized_image = image.resize((resized_width, resized_height)).convert(color_mode)
+        animation_frames.append(resized_image)
+
+    animation_path = "out/Graph.mp4"
+    imageio.mimsave(animation_path, animation_frames, format="mp4")