produced a solution to the problem of funcions not being accessed

neural_network/backprop.py

@@ -1,33 +1,20 @@
 import numpy as np
-from tqdm import tqdm
+from typing import Callable
 
-from neural_network.opts import activation
-
-
-def get_args(args: dict, wb: dict):
-    return (
-        args["epochs"],
-        args["activation_func"],
-        args["func_prime"],
-        args["learning_rate"],
-        wb["W1"],
-        wb["W2"],
-        wb["b1"],
-        wb["b2"],
-    )
+from neural_network.neural_network import NeuralNetwork
 
 
 def fp(
     X_train: np.array,
     y_train: np.array,
-    activation: callable,
+    func: Callable,
     w1: np.array,
     w2: np.array,
     b1: np.array,
     b2: np.array,
 ):
-    n1 = compute_node(arr=X_train, w=w1, b=b1, func=activation)
-    y_hat = compute_node(arr=n1, w=w2, b=b2, func=activation)
+    n1 = compute_node(arr=X_train, w=w1, b=b1, func=func)
+    y_hat = compute_node(arr=n1, w=w2, b=b2, func=func)
     return y_hat, n1, (y_hat-y_train)
 
 
@@ -37,16 +24,15 @@ def bp(
     wb: dict,
     args: dict
 ):
-    epochs, func, func_prime, lr, w1, w2, b1, b2 = get_args(args, wb)
-    r = {}
+    model = NeuralNetwork.from_dict(args | wb)
     loss_history = []
-    for e in tqdm(range(epochs)):
+    for _ in range(model.epochs):
         # forward prop
         y_hat, node1, error = fp(
             X_train=X_train,
             y_train=y_train,
-            actiavtion=func,
-            w1=w1, w2=w2, b1=b1, b2=b2,
+            func=model.activation_func,
+            w1=model.w1, w2=model.w2, b1=model.b1, b2=model.b2,
         )
         mean_squared_error = mse(y_train, y_hat)
         loss_history.append(mean_squared_error)
@@ -54,38 +40,27 @@ def bp(
         # backprop
         dw1 = np.dot(
             X_train.T,
-            np.dot(error * func_prime(y_hat), w2.T) * func_prime(node1),
+            np.dot(error * model.func_prime(y_hat), model.w2.T) *
+            model.func_prime(node1),
         )
         dw2 = np.dot(
             node1.T,
-            error * func_prime(y_hat),
+            error * model.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)
+        db2 = np.sum(error * model.func_prime(y_hat), axis=0)
+        db1 = np.sum(np.dot(error * model.func_prime(y_hat), model.w2.T)
+                     * model.func_prime(node1), axis=0)
 
         # update weights & biases using gradient descent.
         # this is -= and not += because if the gradient descent
         # is positive, we want to go down.
-        w1 -= (lr * dw1)
-        w2 -= (lr * dw2)
-        b1 -= (lr * db1)
-        b2 -= (lr * db2)
+        model.w1 -= (model.learning_rate * dw1)
+        model.w2 -= (model.learning_rate * dw2)
+        model.b1 -= (model.learning_rate * db1)
+        model.b2 -= (model.learning_rate * db2)
 
-        # keeping track of each epochs' numbers
-        r[e] = {
-            "W1": w1,
-            "W2": w2,
-            "b1": b1,
-            "b2": b2,
-            "dw1": dw1,
-            "dw2": dw2,
-            "db1": db1,
-            "db2": db2,
-            "error": error,
-            "mse": mean_squared_error,
-        }
-    return r, loss_history
+    model.set_loss_hist(loss_hist=loss_history)
+    return model
 
 
 def compute_node(arr, w, b, func):

neural_network/main.py

@@ -3,8 +3,6 @@ import numpy as np
 
 from neural_network.opts import activation
 from neural_network.backprop import bp
-from neural_network.model import Network
-from neural_network.plot import loss_history_plt, save_plt
 
 
 def init(
@@ -16,41 +14,35 @@ def init(
     weights and biases to start off the neural_network
     """
     return {
-        "W1": np.random.randn(X.shape[1], hidden_size),
+        "w1": np.random.randn(X.shape[1], hidden_size),
         "b1": np.zeros((1, hidden_size)),
-        "W2": np.random.randn(hidden_size, 1),
+        "w2": np.random.randn(hidden_size, 1),
         "b2": np.zeros((1, 1)),
     }
 
 
-def main(
+def main( 
     X: np.array,
     y: np.array,
     args,
 ) -> None:
     wb = init(X, args["hidden_size"])
+    act = activation[args["activation_func"]]
+    args["activation_func"] = act["main"]
+    args["func_prime"] = act["prime"]
+
     X_train, X_test, y_train, y_test = train_test_split(
         X,
         y,
         test_size=0.3,
         random_state=8675309
     )
+    model = bp(X_train, y_train, wb, args)
 
-    # once we have these results we should test it against
-    # the y_test data
-    results, loss_history = bp(X_train, y_train, wb, args)
-    final = results[args["epochs"] - 1]
-    func = activation[args["activation_func"]]["main"]
-
-    # initialize our final network
-    fm = Network(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}")
+    # evaluate the model and return final results
+    model.eval(
+        X_test=X_test,
+        y_test=y_test,
+    )
+    return model.__dict__
 
-    # plot predicted versus actual
-    # also plot the training loss over epochs
-    animated_loss_plt = loss_history_plt(loss_history)
-    save_plt(animated_loss_plt, "plt.svg", animated=True, fps=30)

neural_network/model.py

@@ -1,20 +0,0 @@
-import numpy as np
-from typing import Callable
-
-
-class Network:
-    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)

neural_network/neural_network.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+from typing import Callable
+import numpy as np
+
+
+@dataclass
+class NeuralNetwork:
+    epochs: int
+    learning_rate: float
+    activation_func: Callable
+    func_prime: Callable
+    hidden_size: int
+    w1: np.array
+    w2: np.array
+    b1: np.array
+    b2: np.array
+
+    mse: float = 0
+    loss_history: list = field(
+        default_factory=lambda: [],
+    )
+
+    def predict(self, x: np.array) -> np.array:
+        n1 = self.compute_node(x, self.w1, self.b1, self.activation_func)
+        return self.compute_node(n1, self.w2, self.b2, self.activation_func)
+
+    def set_loss_hist(self, loss_hist: list) -> None:
+        self.loss_history = loss_hist
+
+    def eval(self, X_test, y_test) -> None:
+        self.mse = np.mean((self.predict(X_test) - y_test) ** 2)
+
+    @staticmethod
+    def compute_node(arr, w, b, func) -> np.array:
+        return func(np.dot(arr, w) + b)
+
+    @classmethod
+    def from_dict(cls, dct):
+        return cls(**dct)

neural_network/plot.py

@@ -1,37 +0,0 @@
-import seaborn as sns
-import matplotlib.pyplot as plt
-from matplotlib.animation import FuncAnimation, FFMpegWriter
-
-sns.set()
-
-"""
-Save plots to the plots folder for when
-we would like to show results on our little
-flask application
-"""
-
-PLT_PATH: str = "static/assets/"
-
-
-def loss_history_plt(loss_history: list) -> FuncAnimation:
-    fig, ax = plt.subplots()
-
-    def animate(i):
-        ax.clear()
-        sns.lineplot(
-            x=range(i),
-            y=loss_history[:i],
-            ax=ax,
-        )
-        ax.set_xlabel("Epoch")
-        ax.set_ylabel("Training Loss")
-
-    return FuncAnimation(fig, animate, frames=len(loss_history), interval=100)
-
-
-def save_plt(plot, filename: str, animated: bool, fps=10):
-    if not animated:
-        plot.savefig(filename)
-        return
-    writer = FFMpegWriter(fps=fps)
-    plot.save(PLT_PATH + filename, writer=writer)