got it working! now I want to make it so that we can have more than just one node in the middle

main.py

@@ -1,18 +1,16 @@
-import numpy as np
 from opts import options
+import numpy as np
+from pprint import pprint
 
 
-def random_dataset():
+def random_dataset(rows: int, features: int):
     """
-    initializes a training and
-    a testing dataset in the form
-    of numpy arrays
+    Initializes a training and a testing dataset in the form of numpy arrays
     """
-    np.random.seed(8675309)
-    return (
-        np.random.randn(10000, 10),
-        np.random.randint(5, size=(10000, 1)),
-    )
+    rng = np.random.default_rng()
+    X = rng.normal(size=(rows, features))
+    y = rng.integers(5, size=(rows, 1))
+    return X, y
 
 
 def main():
@@ -22,8 +20,8 @@ def main():
     except KeyError:
         raise f"Invalid method \"{method}\". Try one of these\n{list(options.keys())}"
 
-    X, y = random_dataset()
-    result = func(X, y)
+    X, y = random_dataset(rows=10, features=2)
+    func(X, y)
 
 
 if __name__ == "__main__":

neural_network/backprop.py

@@ -1,4 +1,5 @@
 import numpy as np
+from tqdm import tqdm
 
 from neural_network.opts import activation
 
@@ -12,21 +13,21 @@ def bp(X_train: np.array, y_train: np.array, wb: dict, args: dict):
     lr = args["learning_rate"]
 
     r = {}
-    for e in range(epochs):
+    for e in tqdm(range(epochs)):
         # forward prop
-        node1 = compute_node(X_train, w1, b1, func)
-        y_hat = compute_node(node1, w2, b2, func)
+        node1 = compute_node(arr=X_train, w=w1, b=b1, func=func)
+        y_hat = compute_node(arr=node1, w=w2, b=b2, func=func)
         error = y_hat - y_train
 
         # backprop
-        dw2 = np.dot(
-            node1.T,
-            error * func_prime(y_hat),
-        )
         dw1 = np.dot(
             X_train.T,
             np.dot(error * func_prime(y_hat), w2.T) * func_prime(node1),
         )
+        dw2 = np.dot(
+            node1.T,
+            error * func_prime(y_hat),
+        )
         db2 = np.sum(error * func_prime(y_hat), axis=0)
         db1 = np.sum(np.dot(error * func_prime(y_hat), w2.T) * func_prime(node1), axis=0)
 
@@ -51,5 +52,8 @@ def bp(X_train: np.array, y_train: np.array, wb: dict, args: dict):
     return r
 
 
-def compute_node(X, w, b, func):
-    return func(np.dot(X, w) + b)
+def compute_node(arr, w, b, func):
+    """
+    Computes nodes during forward prop
+    """
+    return func(np.dot(arr, w) + b)

neural_network/main.py

@@ -1,7 +1,10 @@
 from sklearn.model_selection import train_test_split
-from neural_network.backprop import bp
 import numpy as np
 
+from neural_network.opts import activation
+from neural_network.backprop import bp
+from neural_network.model import Model
+
 
 def get_args() -> dict:
     """
@@ -17,7 +20,7 @@ def get_args() -> dict:
     }
 
 
-def init(X: np.array, y: np.array, hidden_size: int) -> dict:
+def init(X: np.array, hidden_size: int) -> dict:
     """
     returns a dictionary containing randomly initialized
     weights and biases to start off the neural_network
@@ -35,7 +38,7 @@ def main(
         y: np.array,
 ) -> None:
     args = get_args()
-    wb = init(X, y, args["hidden_size"])
+    wb = init(X, args["hidden_size"])
     X_train, X_test, y_train, y_test = train_test_split(
         X,
         y,
@@ -43,4 +46,14 @@ def main(
         random_state=8675309
     )
 
+    # once we have these results we should test it against
+    # the y_test data
     results = bp(X_train, y_train, wb, args)
+    final = results[args["epochs"]-1]
+    func = activation[args["activation_func"]]["main"]
+    fm = Model(final_wb=final, activation_func=func)
+
+    # predict the x test data and compare it to y test data
+    pred = fm.predict(X_test)
+    mse = np.mean((pred - y_test) ** 2)
+    print(f"mean squared error: {mse}")

neural_network/model.py

@@ -0,0 +1,20 @@
+import numpy as np
+from typing import Callable
+
+
+class Model:
+    def __init__(self, final_wb: dict[str, np.array], activation_func: Callable):
+        self.func = activation_func
+        self.final_wb = final_wb
+        self.w1 = final_wb["W1"]
+        self.w2 = final_wb["W2"]
+        self.b1 = final_wb["b1"]
+        self.b2 = final_wb["b2"]
+
+    def predict(self, x: np.array) -> np.array:
+        n1 = self.compute_node(x, self.w1, self.b1, self.func)
+        return self.compute_node(n1, self.w2, self.b2, self.func)
+
+    @staticmethod
+    def compute_node(arr, w, b, func):
+        return func(np.dot(arr, w) + b)

requirements.txt

@@ -1,2 +1,3 @@
 numpy==1.24.2
 scikit_learn==1.2.2
+tqdm==4.65.0