compile e2e benchmarks (#163)

Author: ev-br

.gitattributes

@@ -0,0 +1 @@
+e2e/smole/*mp4 binary

e2e/mojo_mandelbrot/compiled.py

@@ -0,0 +1,85 @@
+import numpy as np      # otherwise @compile is ImportError
+import torch._dynamo.config as cfg
+import torch
+
+cfg.numpy_ndarray_as_tensor = True
+device="cpu"
+
+
+def init():
+    # Define the boundaries of the complex plane
+    xn = 450
+    yn = 375
+    xmin = -2.25
+    xmax = 0.75
+    ymin = -1.25
+    ymax = 1.25
+
+    # Create the grid of complex numbers
+    x_values = np.linspace(xmin, xmax, xn, dtype='float32')
+    y_values = np.linspace(ymin, ymax, yn, dtype='float32')
+
+    rx, iy = np.meshgrid(x_values, y_values, indexing='xy')
+
+    return rx, iy
+
+
+def simulate(rx, iy, step, max_iter=200):
+    x = rx.copy()
+    y = iy.copy()
+    mask = np.zeros_like(x)
+    for _ in range(max_iter):
+        mask = step(x, y, rx, iy, mask)
+    return mask
+
+
+def step(x, y, rx, iy, mask):
+    x_prev = x
+    y_prev = y
+    x = x_prev**2 - y_prev**2 + rx
+    y = 2*x_prev*y_prev + iy
+    inside = np.sqrt(x**2 + y**2) <= 2      # sqrt is from the OP
+    mask += inside
+    return mask
+
+
+
+rx, iy = init()
+mask = simulate(rx, iy, step, max_iter=3)
+
+print(np.count_nonzero(mask))
+
+
+################ benchmark #####################
+import time
+
+# ### numpy ###
+
+
+rx, iy = init()
+start_time = time.time()
+mask = simulate(rx, iy, step, max_iter=1000)
+end_time = time.time()
+numpy_time = end_time - start_time
+print("\n\nnumpy:    elapsed=", numpy_time)
+
+
+# ### compile ###
+
+step_c = torch.compile(step)
+
+# ### warm up ###
+rx, iy = init()
+for _ in range(50):
+    simulate(rx, iy, step_c, max_iter=3)
+
+
+rx, iy = init()
+start_time = time.time()
+mask = simulate(rx, iy, step_c, max_iter=1000)
+end_time = time.time()
+
+
+compiled_time = end_time - start_time
+print("compiled: elapsed=", compiled_time, '  speedup = ', numpy_time / compiled_time)
+

e2e/nn_from_scratch/eager/nn.py

@@ -0,0 +1,171 @@
+# from https://www.geeksforgeeks.org/implementation-of-neural-network-from-scratch-using-numpy/
+
+
+import numpy as _np
+import torch_np as np
+
+# To run on CUDA, change "cpu" to "cuda" below.
+import torch
+torch.set_default_device("cpu")
+
+
+# Creating data set
+ 
+# A
+a =[0, 0, 1, 1, 0, 0,
+   0, 1, 0, 0, 1, 0,
+   1, 1, 1, 1, 1, 1,
+   1, 0, 0, 0, 0, 1,
+   1, 0, 0, 0, 0, 1]
+# B
+b =[0, 1, 1, 1, 1, 0,
+   0, 1, 0, 0, 1, 0,
+   0, 1, 1, 1, 1, 0,
+   0, 1, 0, 0, 1, 0,
+   0, 1, 1, 1, 1, 0]
+# C
+c =[0, 1, 1, 1, 1, 0,
+   0, 1, 0, 0, 0, 0,
+   0, 1, 0, 0, 0, 0,
+   0, 1, 0, 0, 0, 0,
+   0, 1, 1, 1, 1, 0]
+ 
+# Creating labels
+y =[[1, 0, 0],
+   [0, 1, 0],
+   [0, 0, 1]]
+
+
+# converting data and labels into numpy array
+ 
+"""
+Convert the matrix of 0 and 1 into one hot vector
+so that we can directly feed it to the neural network,
+these vectors are then stored in a list x.
+"""
+ 
+x =[np.array(a).reshape(1, 30), np.array(b).reshape(1, 30),
+                                np.array(c).reshape(1, 30)]
+ 
+ 
+# Labels are also converted into NumPy array
+y = np.array(y)
+ 
+ 
+print(x, "\n\n", y)
+
+
+# activation function
+
+def sigmoid(x):
+    return(1/(1 + np.exp(-x)))
+
+# Creating the Feed forward neural network
+# 1 Input layer(1, 30)
+# 1 hidden layer (1, 5)
+# 1 output layer(3, 3)
+
+def f_forward(x, w1, w2):
+    # hidden
+    z1 = x.dot(w1)# input from layer 1
+    a1 = sigmoid(z1)# out put of layer 2
+    
+    # Output layer
+    z2 = a1.dot(w2)# input of out layer
+    a2 = sigmoid(z2)# output of out layer
+    return(a2)
+
+# initializing the weights randomly
+def generate_wt(x, y):
+
+    _np.random.seed(1234)
+
+    l =[]
+    for i in range(x * y):
+        l.append(_np.random.randn())
+    return(np.array(l).reshape(x, y))
+    
+# for loss we will be using mean square error(MSE)
+def loss(out, Y):
+    s =(np.square(out-Y))
+    s = np.sum(s)/len(y)
+    return(s)
+
+# Back propagation of error
+def back_prop(x, y, w1, w2, alpha):
+    
+    # hidden layer
+    z1 = x.dot(w1)# input from layer 1
+    a1 = sigmoid(z1)# output of layer 2
+    
+    # Output layer
+    z2 = a1.dot(w2)# input of out layer
+    a2 = sigmoid(z2)# output of out layer
+    # error in output layer
+    d2 =(a2-y)
+    d1 = np.multiply((w2.dot((d2.transpose()))).transpose(),
+                                (np.multiply(a1, 1-a1)))
+
+    # Gradient for w1 and w2
+    w1_adj = x.transpose().dot(d1)
+    w2_adj = a1.transpose().dot(d2)
+    
+    # Updating parameters
+    w1 = w1-(alpha*(w1_adj))
+    w2 = w2-(alpha*(w2_adj))
+    
+    return(w1, w2)
+
+def train(x, Y, w1, w2, alpha = 0.01, epoch = 10):
+    acc =[]
+    losss =[]
+    for j in range(epoch):
+        l =[]
+        for i in range(len(x)):
+            out = f_forward(x[i], w1, w2)
+            l.append((loss(out, Y[i])))
+            w1, w2 = back_prop(x[i], y[i], w1, w2, alpha)
+        print("epochs:", j + 1, "======== acc:", (1-(sum(l)/len(x)))*100)
+        acc.append((1-(sum(l)/len(x)))*100)
+        losss.append(sum(l)/len(x))
+    return(acc, losss, w1, w2)
+
+def predict(x, w1, w2):
+    Out = f_forward(x, w1, w2)
+    maxm = 0
+    k = 0
+    for i in range(len(Out[0])):
+        if(maxm<Out[0][i]):
+            maxm = Out[0][i]
+            k = i
+    if(k == 0):
+        print("Image is of letter A.")
+    elif(k == 1):
+        print("Image is of letter B.")
+    else:
+        print("Image is of letter C.")
+#    plt.imshow(x.reshape(5, 6))
+#    plt.show()
+
+w1 = generate_wt(30, 5)
+w2 = generate_wt(5, 3)
+print(w1, "\n\n", w2)
+
+
+"""The arguments of train function are data set list x,
+correct labels y, weights w1, w2, learning rate = 0.1,
+no of epochs or iteration.The function will return the
+matrix of accuracy and loss and also the matrix of
+trained weights w1, w2"""
+
+acc, losss, w1, w2 = train(x, y, w1, w2, 0.1, 100)
+
+
+"""
+The predict function will take the following arguments:
+1) image matrix
+2) w1 trained weights
+3) w2 trained weights
+"""
+predict(x[1], w1, w2)
+