handling errors well with the neural netork api

nn/activation.py

@@ -0,0 +1,46 @@
+from typing import Callable
+from nn.nn import NN
+import numpy as np
+
+
+def get_activation(nn: NN) -> Callable:
+    a = nn.activation
+    funcs = {
+        "relu": relu,
+        "sigmoid": sigmoid,
+        "tanh": tanh,
+    }
+
+    prime_funcs = {
+        "sigmoid": sigmoid_prime,
+        "tanh": tanh_prime,
+        "relu": relu_prime,
+    }
+
+    nn.set_func(funcs[a])
+    nn.set_func_prime(funcs[a])
+
+
+def relu(x):
+    return np.max(0.0, x)
+
+
+def relu_prime(x):
+    return
+
+
+def sigmoid(x):
+    return 1.0 / (1.0 + np.exp(-x))
+
+
+def sigmoid_prime(x):
+    s = sigmoid(x)
+    return s / (1.0 - s)
+
+
+def tanh(x):
+    return np.tanh(x)
+
+
+def tanh_prime(x):
+    return

nn/nn.py

@@ -1,4 +1,6 @@
+from typing import Callable
 import pandas as pd
+import numpy as np
 
 
 class NN:
@@ -12,6 +14,11 @@ class NN:
         features: list[str],
         target: str,
         data: str,
+
+        wh: np.array,
+        wo: np.array,
+        bh: np.array,
+        bo: np.array,
     ):
         self.epochs = epochs
         self.hidden_size = hidden_size
@@ -21,8 +28,29 @@ class NN:
         self.features = features
         self.target = target
         self.data = data
+        self.wh: np.array = wh
+        self.wo: np.array = wo
+        self.bh: np.array = bh
+        self.bo: np.array = bo
 
+        self.func_prime: Callable = None
+        self.func: Callable = None
         self.df: pd.DataFrame = None
+        self.X: pd.DataFrame = None
+        self.y: pd.DataFrame = None
+
+    def read_csv(self) -> dict[str, str]:
+        self.df = pd.read_csv(self.data)
+        self.X = self.df[self.features]
+        self.y = self.df[self.target]
+
+    def set_func(self, f: Callable) -> None:
+        assert isinstance(f, Callable)
+        self.func = f
+
+    def set_func_prime(self, f: Callable) -> None:
+        assert isinstance(f, Callable)
+        self.func_prime = f
 
     @classmethod
     def from_dict(cls, dct):

nn/train.py

@@ -4,7 +4,7 @@ import pandas as pd
 import numpy as np
 
 
-def train(nn: NN):
+def train(nn: NN) -> dict:
     X_train, X_test, y_train, y_test = train_test_split(
         nn.X,
         nn.y,
@@ -12,4 +12,4 @@ def train(nn: NN):
         random_state=88,
     )
 
-
+    return {"status": "you made it!"}