nn-with-backprop-pk 0.1.0__py3-none-any.whl

nn_with_backprop_pk/core/backprop.py

@@ -0,0 +1,72 @@
+import os
+import numpy as np
+from typing import List, Tuple, Literal
+from src.nn_with_backprop_pk.core.feed_forward import FeedForward
+from src.nn_with_backprop_pk.utils.activations import sigmoid, relu, tanh
+from src.nn_with_backprop_pk.utils.derivatives import diff_sigmoid, diff_binary_cross_entropy
+from src.nn_with_backprop_pk.utils.loss_functions import mean_squared_error, binary_cross_entropy
+
+activation_funcs = {
+    "sigmoid": sigmoid,
+    "relu": relu,
+    "tanh": tanh
+}
+
+loss_funcs = {
+    "mean_squared_error": mean_squared_error,
+    "binary_cross_entropy": binary_cross_entropy
+}
+
+LossType = Literal["mean_squared_error", "binary_cross_entropy"]
+
+class BackProp():
+
+    def __init__(self, forward_pass: FeedForward, learning_rate: float, loss_function: LossType):
+        self.ff = forward_pass #not forward_pass() since "()" creates an instance, but we just need to pass an instance while using these classes
+        self.learning_rate = learning_rate
+        self.loss_function = loss_function
+
+    def back_prop(self) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+        # self.deltas_ = [np.zeros_like(s) for s in self.ff.net.layers]
+        # del self.deltas_[0]
+        self.deltas = []
+        # self.diff_losses_weights_ = [np.zeros_like(s) for s in self.ff.net.weights]
+        # self.diff_losses_biases_ = [np.zeros_like(s) for s in self.ff.net.biases]
+        self.diff_losses_weights = []
+        self.diff_losses_biases = []
+
+        if self.ff.net.activations_layers[-1] == "sigmoid" and self.loss_function == "binary_cross_entropy":
+            # Special case: when using sigmoid activation + binary cross-entropy loss,
+            # the gradient simplifies to (y_pred - y_true)
+            # Look at the docs for this special case
+            self.del_final = self.ff.net.layers[-1] - self.ff.net.label[0].reshape(self.ff.net.label.shape[1],1) 
+        else: 
+            #Example - self.del_final = diff_sigmoid(self.ff.net.layers[-1]) * diff_binary_cross_entropy(self.ff.net.layers[-1], self.ff.net.label.reshape(self.ff.net.label.shape[1],1))
+
+            raise NotImplementedError(
+                f"Delta not implemented for combination:\n"
+                f"  Loss function     : {self.loss_function}\n"
+                f"  Output activation : {self.ff.net.activations_layers[-1]}"
+            ) 
+        self.deltas.append(self.del_final)
+        for i in range(len(self.ff.net.layers)-1, 1, -1):
+            self.deltas.append((self.ff.net.weights[i-1].T @ self.deltas[-1]) * diff_sigmoid(self.ff.net.layers[i-1]))
+        self.deltas = self.deltas[::-1]
+        for i in range(len(self.deltas)):
+            # der_w = self.layers[i] @ self.deltas[i].T
+            der_w = self.deltas[i] @ self.ff.net.layers[i].T
+            self.diff_losses_weights.append(der_w)
+            der_b = self.deltas[i]
+            self.diff_losses_biases.append(der_b)
+        
+        return self.diff_losses_weights, self.diff_losses_biases
+    
+    def update_parameters(self) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+        for i in range(len(self.ff.net.weights)):
+            self.ff.net.weights[i] -= self.learning_rate * self.diff_losses_weights[i]
+            self.ff.net.biases[i] -= self.learning_rate * self.diff_losses_biases[i]
+        return self.ff.net.weights, self.ff.net.biases
+
+    
+
+    

nn_with_backprop_pk/core/feed_forward.py

@@ -0,0 +1,26 @@
+import numpy as np
+from src.nn_with_backprop_pk.core.layers import NeuNet
+from src.nn_with_backprop_pk.utils.activations import sigmoid, relu, tanh
+
+activation_funcs = {
+    "sigmoid": sigmoid,
+    "relu": relu,
+    "tanh": tanh
+}
+
+class FeedForward():
+
+    def __init__(self, net: NeuNet):
+        self.net = net
+
+    def forward_pass(self, data_sample: np.ndarray = None) -> None:
+        
+        self.net.layers[0] = data_sample.reshape(self.net.tr_data.shape[1],1)
+        for i in range(len(self.net.layers)-1):
+            if self.net.layers[i].ndim != 2:
+                self.net.layers[i] = self.net.layers[i].reshape(self.net.tr_data.shape[1], 1)
+            self.net.layers[i+1] = self.net.weights[i] @ self.net.layers[i] + self.net.biases[i]
+            ac_func = activation_funcs[self.net.activations_layers[i]]
+            self.net.layers[i+1] = ac_func(self.net.layers[i+1])
+            
+            

nn_with_backprop_pk/core/layers.py

@@ -0,0 +1,38 @@
+# import Packages
+
+import os
+import numpy as np
+import logging
+from time import time
+import pandas as pd
+from src.nn_with_backprop_pk.utils.parameters_init import xavier_init
+from typing import Literal
+
+ActivationType = Literal["relu", "sigmoid", "tanh"]
+
+class NeuNet():
+
+    def __init__(self, tr_X: np.ndarray, tr_y:np.ndarray):
+        self.layers = []
+        self.activations_layers = []
+        self.tr_data = tr_X
+        self.label = tr_y
+    
+    def input_layer(self) -> None:
+        # self.layers.append(self.tr_data[0].reshape(self.tr_data.shape[1],1))
+        self.layers.append(np.zeros((self.tr_data.shape[1],1), dtype=np.float64))
+
+    def add_hidden_layer(self, neurons: int, activation: ActivationType) -> None:
+        self.layers.append(np.zeros((neurons,1), dtype=np.float64))
+        self.activations_layers.append(activation)
+    
+    def output_layer(self, neurons: int, activation: ActivationType) -> None:
+        self.layers.append(np.zeros((neurons,1), dtype=np.float64))
+        self.activations_layers.append(activation)
+    
+    def initialize_weights(self) -> None:
+        self.shape = [(self.layers[i+1].shape[0], self.layers[i].shape[0]) for i in range(len(self.layers)-1)]
+        self.weights = [xavier_init(i) for i in self.shape]
+        self.biases = [xavier_init((i[0],1)) for i in self.shape]
+        
+    

nn_with_backprop_pk/core/learner.py

@@ -0,0 +1,78 @@
+import numpy as np
+from src.nn_with_backprop_pk.core.backprop import BackProp
+from src.nn_with_backprop_pk.utils.activations import sigmoid, relu, tanh
+from src.nn_with_backprop_pk.utils.derivatives import diff_sigmoid, diff_binary_cross_entropy
+from src.nn_with_backprop_pk.utils.loss_functions import binary_cross_entropy
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import logging
+# Set up logging once in your main script or module
+logging.basicConfig(level=logging.INFO)
+
+class Learner(BackProp):
+
+    def __init__(self, backprop: BackProp, epoch: int):
+        
+        self.bp = backprop
+        self.epoch = epoch
+
+    def calculate_loss(self, predicted_sample, actual_sample) -> float:
+        list_loss = []
+        # for i in range(len(self.bp.ff.net.layers[-1])):
+        # _loss = binary_cross_entropy(self.bp.ff.net.layers[-1], self.bp.ff.net.label[0])
+        _loss = binary_cross_entropy(predicted_sample, actual_sample)
+            # list_loss.append(_loss)
+        # avg_loss = sum(list_loss) / len(list_loss)
+
+        return _loss
+    
+    def train(self):
+        self.loss_epoch_avg = []
+        for i in range(self.epoch):
+            loss_epoch = []
+            for j in range(len(self.bp.ff.net.tr_data)):
+
+                self.bp.ff.forward_pass(self.bp.ff.net.tr_data[j])
+                d_w, d_b = self.bp.back_prop()
+                # logging.info(np.linalg.norm(d_w[-1]))
+                self.bp.update_parameters()
+                reshaped_label = self.bp.ff.net.label[j].reshape(self.bp.ff.net.label.shape[1], 1)
+                loss_epoch.append(self.calculate_loss(self.bp.ff.net.layers[-1], reshaped_label))
+
+                # # Update input layer
+                # self.bp.ff.net.layers[0] = self.bp.ff.net.tr_data[j+1]
+            self.loss_epoch_avg.append(sum(loss_epoch) / len(loss_epoch))
+            logging.info(f"Loss - {sum(loss_epoch) / len(loss_epoch)}")
+            logging.info(f"Epoch: {str(i)} - Average Loss: {self.loss_epoch_avg[-1]}")
+        
+        return self.loss_epoch_avg
+    
+    def plot_loss(self)-> None:
+        
+        fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+        ax.plot(list(range(self.epoch)), self.loss_epoch_avg)
+        ax.set_title("Loss vs epoch")
+        ax.set_xlabel("Epochs")
+        ax.set_ylabel("Average Loss")
+        plt.tight_layout()
+        plt.show()
+
+        return None
+    
+    def binary_classification_accuracy(self, test_data: np.ndarray, test_label: np.ndarray) -> np.float64:
+        preds = []
+        for i in range(test_data.shape[0]):
+            # self.bp.ff.net = self.bp.ff.net(test_X, test_y)
+            self.bp.ff.forward_pass(test_data[i].reshape(test_data.shape[1], 1))
+            if self.bp.ff.net.layers[-1] < 0.5:
+                preds.append(0)
+            else: 
+                preds.append(1)
+        preds_arr = np.array(preds)
+        if test_label.ndim > 1:
+            test_label = test_label.reshape(test_label.shape[0],)
+        
+        return sum(test_label == preds_arr) / len(test_label)
+
+
+    

nn_with_backprop_pk/utils/activations.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+def sigmoid(x: np.ndarray) -> np.ndarray: 
+    return 1 / (1 + np.exp(-x))
+
+def relu(x: np.ndarray) -> np.ndarray: 
+    return np.maximum(0, x)
+    
+def tanh(x: np.ndarray) -> np.ndarray: 
+    return ((np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x)))

nn_with_backprop_pk/utils/data_randomize.py

@@ -0,0 +1,12 @@
+import random
+import pandas as pd
+
+def df_random(tr_data: pd.DataFrame) -> pd.DataFrame:
+
+    if not isinstance(tr_data, pd.DataFrame):
+        raise NotImplementedError("Code not yet implemented for data other than pandas dataframe!")
+
+    random_list = random.sample(range(0, tr_data.shape[0]), tr_data.shape[0])
+    rand_df = tr_data.loc[random_list]
+
+    return rand_df

nn_with_backprop_pk/utils/data_split.py

@@ -0,0 +1,19 @@
+from typing import Tuple
+import pandas as pd
+from math import ceil
+
+class SplitFactor(float):
+    def __new__(cls, val):
+        if not 0.6 <= val <=0.9:
+            raise ValueError(f"The value must be between 0.6 and 0.9. Provided {val}.")
+        return float.__new__(cls, val)
+
+def train_test_split(df: pd.DataFrame, split_factor: SplitFactor) -> Tuple[pd.DataFrame, pd.DataFrame]:
+
+    split_factor = SplitFactor(split_factor)
+    total_rows = df.shape[0]
+    ratio = ceil(total_rows * split_factor)
+    train_data = df.iloc[:ratio, :]
+    test_data = df.iloc[ratio:, :] 
+
+    return train_data, test_data

nn_with_backprop_pk/utils/derivatives.py

@@ -0,0 +1,25 @@
+import numpy as np
+from src.nn_with_backprop_pk.utils.activations import sigmoid, tanh
+
+def diff_mse(y_pred: np.ndarray, y_actual: np.ndarray) -> np.ndarray:
+    return y_pred - y_actual
+
+def diff_binary_cross_entropy(y_pred: np.ndarray, y_actual: np.ndarray) -> np.ndarray:
+    epsilon = 1e-15 #to prevent log(0)
+    y_pred = np.clip(y_pred, epsilon, 1 - epsilon) # to prevent values like 0 and 1
+    return -((y_actual / y_pred) - ((1-y_actual)/(1-y_pred)))
+
+# def diff_sigmoid(x: np.ndarray) -> np.ndarray:
+#     s = sigmoid(x)
+#     return s * (1 -s)
+
+def diff_sigmoid(x: np.ndarray) -> np.ndarray:
+    # s = sigmoid(x)
+    return x * (1 -x)
+
+def diff_relu(x: np.ndarray) -> np.ndarray:
+    return np.where(x > 0, 1, 0)
+
+def diff_tanh(x: np.ndarray) -> np.ndarray:
+    t = tanh(x)
+    return 1 - t**2

nn_with_backprop_pk/utils/loss_functions.py

@@ -0,0 +1,13 @@
+import numpy as np
+import math
+
+def mean_squared_error(y_pred: np.ndarray, y_actual: np.ndarray) -> float:
+    loss = 0.5 * np.mean((y_pred - y_actual) ** 2)
+    return loss
+
+def binary_cross_entropy(y_pred: np.ndarray, y_actual: np.ndarray) -> float:
+    epsilon = 1e-15 #to prevent log(0)
+    y_pred = np.clip(y_pred, epsilon, 1 - epsilon) # to prevent values like 0 and 1
+    loss = -np.mean((y_actual * np.log(y_pred)) + ((1 - y_actual)*np.log(1 - y_pred)))
+    return loss
+

nn_with_backprop_pk/utils/parameters_init.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+def xavier_init(shape: tuple) -> np.ndarray:
+    if not isinstance(shape, tuple):
+        raise TypeError(f"Shape must be a tuple, got {type(shape)}: {shape}")
+    if len(shape) == 1:
+        dim = shape[0]
+        limit = np.sqrt(6 / (dim + dim))
+    elif len(shape) == 2:
+        in_dim, out_dim = shape
+        limit = np.sqrt(6 / (in_dim + out_dim))
+    else:
+        raise ValueError(f"Unsupported Shape: {shape}")
+    
+    return np.random.uniform(-limit, limit, size=shape)
+
+def he_init(shape: tuple) -> np.ndarray:
+    if not isinstance(shape, tuple):
+        raise TypeError(f"Shape must be a tuple, got {type(shape)}: {shape}")
+    if len(shape) == 1:
+        in_dim = shape[0]
+    elif len(shape) == 2:
+        in_dim, _ = shape
+    else:
+        raise ValueError(f"Unsupported Shape: {shape}")
+    std = np.sqrt(2 / in_dim)
+
+    return np.random.randn(*shape) * std

nn_with_backprop_pk-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: nn-with-backprop-pk
+Version: 0.1.0
+Summary: Poetry file for the project NN with backprop
+Author: ppkhairn
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: matplotlib (>=3.10.3,<4.0.0)
+Requires-Dist: numpy (>=2.3.1,<3.0.0)
+Requires-Dist: pandas (>=2.3.0,<3.0.0)
+Requires-Dist: pytest (>=8.4.1,<9.0.0)
+Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
+Requires-Dist: setuptools (>=80.9.0,<81.0.0)
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
+Requires-Dist: wheel (>=0.45.1,<0.46.0)
+Description-Content-Type: text/markdown
+
+# NN_with_backprop

nn_with_backprop_pk-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+nn_with_backprop_pk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nn_with_backprop_pk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nn_with_backprop_pk/core/backprop.py,sha256=MHM4pu-SkvO3OH3X1R81h7pBtXdoUYjG0jFK68PXbSM,3337
+nn_with_backprop_pk/core/feed_forward.py,sha256=HxENzI__yZh2l6dA_tS_c71_EK7NCg0ld-4P1hL2N7Q,915
+nn_with_backprop_pk/core/layers.py,sha256=8nMAd-BAtYHO-gEGDU-KUP7MrVPiUt4qBTbvRtxXQ9o,1351
+nn_with_backprop_pk/core/learner.py,sha256=4unRm9S2-RZOJOfZ-GYAtMby4hsOjxAiPepnUabz5bc,3037
+nn_with_backprop_pk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nn_with_backprop_pk/utils/activations.py,sha256=Z-tdarGfvvbYBoga-gBzilETqNz1Rxr73_tLm182VSc,272
+nn_with_backprop_pk/utils/data_randomize.py,sha256=EoShHsudYQX8ZEVUJLyNCUyAAXZCdgADjinYBEJqyrc,374
+nn_with_backprop_pk/utils/data_split.py,sha256=EM9sPIa1Izlr_rLHKCgbhGYNYHSVrZrnTa_W4rO1Hq0,610
+nn_with_backprop_pk/utils/derivatives.py,sha256=9zUuEdKDh4tCRwnk1qTM6j7xilTSwoROdcBJkqzvHa4,804
+nn_with_backprop_pk/utils/loss_functions.py,sha256=QQszQm-p-OGaX0xTk8wMNl5GTHabJxrVQYU2fxRhwDI,479
+nn_with_backprop_pk/utils/parameters_init.py,sha256=rSBXYQ3Ozz5C0eszNcpVgbmq0-EOp6BOtow0IYHu8iA,897
+nn_with_backprop_pk-0.1.0.dist-info/METADATA,sha256=2TS2NjH3YtnCEHfhFdX53wQY0-zWiBc6THS_orG8B6U,651
+nn_with_backprop_pk-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+nn_with_backprop_pk-0.1.0.dist-info/RECORD,,

nn_with_backprop_pk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any