Merge pull request #2 from Jensen-holm/dev

example.py

@@ -1,7 +1,7 @@
 from sklearn import datasets
 from sklearn.preprocessing import OneHotEncoder
 from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score, precision_score, recall_score
+from sklearn.metrics import accuracy_score
 import numpy as np
 from numpyneuron import (
     NN,
@@ -14,7 +14,7 @@ from numpyneuron import (
 RANDOM_SEED = 2
 
 
-def _preprocess_digits(
+def preprocess_digits(
     seed: int,
 ) -> tuple[np.ndarray, ...]:
     digits = datasets.load_digits(as_frame=False)
@@ -30,9 +30,10 @@ def _preprocess_digits(
     return X_train, X_test, y_train, y_test
 
 
-def train_nn_classifier() -> None:
-    X_train, X_test, y_train, y_test = _preprocess_digits(seed=RANDOM_SEED)
-
+def train_nn_classifier(
+    X_train: np.ndarray,
+    y_train: np.ndarray,
+) -> NN:
     nn_classifier = NN(
         epochs=2_000,
         hidden_size=16,
@@ -50,16 +51,16 @@ def train_nn_classifier() -> None:
         X_train=X_train,
         y_train=y_train,
     )
+    return nn_classifier
+
 
-    pred = nn_classifier.predict(X_test=X_test)
+if __name__ == "__main__":
+    X_train, X_test, y_train, y_test = preprocess_digits(seed=RANDOM_SEED)
+    classifier = train_nn_classifier(X_train, y_train)
 
+    pred = classifier.predict(X_test)
     pred = np.argmax(pred, axis=1)
     y_test = np.argmax(y_test, axis=1)
 
     accuracy = accuracy_score(y_true=y_test, y_pred=pred)
-
     print(f"accuracy on validation set: {accuracy:.4f}")
-
-
-if __name__ == "__main__":
-    train_nn_classifier()

numpyneuron/__init__.py

@@ -8,3 +8,9 @@ ACTIVATIONS: dict[str, Activation] = {
     "TanH": TanH(),
     "SoftMax": SoftMax(),
 }
+
+LOSSES: dict[str, Loss] = {
+    "MSE": MSE(),
+    "CrossEntropy": CrossEntropy(),
+    "CrossEntropyWithLogitsLoss": CrossEntropyWithLogits(),
+}

numpyneuron/activation.py

@@ -4,11 +4,11 @@ from abc import abstractmethod, ABC
 
 class Activation(ABC):
     @abstractmethod
-    def forward(self, X: np.ndarray) -> np.ndarray:
+    def forward(X: np.ndarray) -> np.ndarray:
         pass
 
     @abstractmethod
-    def backward(self, X: np.ndarray) -> np.ndarray:
+    def backward(X: np.ndarray) -> np.ndarray:
         pass
 
 

numpyneuron/loss.py

@@ -4,12 +4,14 @@ import numpy as np
 
 
 class Loss(ABC):
+    @staticmethod
     @abstractmethod
-    def forward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    def forward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         pass
 
+    @staticmethod
     @abstractmethod
-    def backward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    def backward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         pass
 
 
@@ -18,19 +20,22 @@ class LogitsLoss(Loss):
 
 
 class MSE(Loss):
-    def forward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def forward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         return np.sum(np.square(y_hat - y_true)) / y_true.shape[0]
 
-    def backward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def backward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         return (y_hat - y_true) * (2 / y_true.shape[0])
 
 
 class CrossEntropy(Loss):
-    def forward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def forward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         y_hat = np.asarray(y_hat)
         y_true = np.asarray(y_true)
         m = y_true.shape[0]
-        p = self._softmax(y_hat)
+        p = SoftMax().forward(y_hat)
         eps = 1e-15  # to prevent log(0)
         log_likelihood = -np.log(
             np.clip(p[range(m), y_true.argmax(axis=1)], a_min=eps, a_max=None)
@@ -38,19 +43,17 @@ class CrossEntropy(Loss):
         loss = np.sum(log_likelihood) / m
         return loss
 
-    def backward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def backward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         y_hat = np.asarray(y_hat)
         y_true = np.asarray(y_true)
         grad = y_hat - y_true
         return grad / y_true.shape[0]
 
-    @staticmethod
-    def _softmax(X: np.ndarray) -> np.ndarray:
-        return SoftMax().forward(X)
-
 
 class CrossEntropyWithLogits(LogitsLoss):
-    def forward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def forward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         # Apply the log-sum-exp trick for numerical stability
         max_logits = np.max(y_hat, axis=1, keepdims=True)
         log_sum_exp = np.log(np.sum(np.exp(y_hat - max_logits), axis=1, keepdims=True))
@@ -59,17 +62,11 @@ class CrossEntropyWithLogits(LogitsLoss):
         loss = -np.sum(log_probs * y_true) / y_true.shape[0]
         return loss
 
-    def backward(self, y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def backward(y_hat: np.ndarray, y_true: np.ndarray) -> np.ndarray:
         # Compute softmax probabilities
         exps = np.exp(y_hat - np.max(y_hat, axis=1, keepdims=True))
         probs = exps / np.sum(exps, axis=1, keepdims=True)
         # Subtract the one-hot encoded labels from the probabilities
         grad = (probs - y_true) / y_true.shape[0]
         return grad
-
-
-LOSSES: dict[str, Loss] = {
-    "MSE": MSE(),
-    "CrossEntropy": CrossEntropy(),
-    "CrossEntropyWithLogitsLoss": CrossEntropyWithLogits(),
-}