neuralnetworknumpy 0.2.0__tar.gz → 0.2.1__tar.gz

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnetworknumpy
-Version: 0.2.0
+Version: 0.2.1
 Summary: A neural network framework built completely from scratch using NumPy
 Author: Itamar Senderovitz
 License: MIT

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/neuralnetworknumpy/layers/BatchNorm.py

@@ -116,8 +116,8 @@ class BatchNorm(Layer):
         # Mean derivative
         # dmean = Σ (dX̂ * - (σ² + ε)^(1/2)) + dvar * Σ (-2 * (X - μ)) / m
         dmean = (
-                np.sum(dX_hat * -var_inv, axis=(0, 1, 2), keepdims=True)
-                + dvar * np.sum(-2. * (self.A_prev - self.mean), axis=(0, 1, 2), keepdims=True) / m
+                np.sum(dX_hat * -var_inv, axis=(0, ), keepdims=True)
+                + dvar * np.sum(-2. * (self.A_prev - self.mean), axis=(0, ), keepdims=True) / m
         )
 
         # Total derivative

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/neuralnetworknumpy/model.py

@@ -324,11 +324,11 @@ class NeuralNetwork:
 
 
     # Backward function - locates the origin of the loss and tweaks it
-    def _backward(self, y_true):
+    def _backward(self, y_pred, y_true):
       m = y_true.size
 
 
-      dA = self._loss_derivative(self.layers[-1].A, y_true) / m
+      dA = self._loss_derivative(y_pred, y_true) / m
       dA = self.layers[-1]._backward(dA)
 
       # Remaining layers
@@ -478,7 +478,7 @@ class NeuralNetwork:
     @staticmethod
     def shuffle_data(x, y):
         perm = np.random.permutation(y.size)
-        x = x[perm] if x.ndim > 2 else x[:, perm]
+        x = x[perm]
         y = y[perm]
         return x, y
 
@@ -488,10 +488,10 @@ class NeuralNetwork:
 
 
     def check_gradient(self, X, y):
-      assert X.shape[1] == y.size, f"X has {X.shape[1]} samples but y has {y.size}"
+      assert X.shape[0] == y.size, f"X has {X.shape[0]} samples but y has {y.size}"
 
       # Use a small batch to avoid numerical issues
-      X = X[:, :8].astype(np.float64)  # <-- float64 is critical for numerical grad
+      X = X[:8].astype(np.float64)  # <-- float64 is critical for numerical grad
       y = y[:8]
 
       rel_diff = []
@@ -499,8 +499,8 @@ class NeuralNetwork:
       self.lambda_ = 0.0
       epsilon = 1e-5  # smaller epsilon can help
 
-      self._forward(X, training=False)
-      self._backward(y)
+      y_pred = self._forward(X, training=False)
+      self._backward(y_pred, y)
 
       # Snapshot ALL analytical gradients before any weight perturbation
       analytical_grads = {}
@@ -577,18 +577,17 @@ class NeuralNetwork:
           optimizer_t += 1
 
           # get batch
-          x_batch = x_shuffled[i:i + batch_size] if X.ndim > 2 else x_shuffled[:, i:i + batch_size]
+          x_batch = x_shuffled[i:i + batch_size]
           y_batch = y_shuffled[i:i + batch_size]
           # feed model
-          self._forward(x_batch)
-          self._backward(y_batch)
+          y_pred = self._forward(x_batch)
+          self._backward(y_pred, y_batch)
           self._update(optimizer_t)
 
-          y_pred = self.layers[-1].A
           # Monitor loss - epoch_loss = Avg(batches_loss)
           predictions.append(self._decode_output(y_pred))
           batch_loss = self._compute_loss(y_pred, y_batch)
-          epoch_loss += batch_loss * n_samples / X.shape[1]
+          epoch_loss += batch_loss * n_samples / X.shape[0]
 
           # Check Gradient - make sure backpropagation works well
           #self.check_gradient(x_batch, y_batch)
@@ -644,8 +643,8 @@ class NeuralNetwork:
 
     # Train the model
     def fit(self, X, y, X_val=None, y_val=None, epochs=10, batch_size=1):
-        """if X.shape[1] != y.size:
-            raise ValueError("Mismatch between samples and labels")"""
+        if X.shape[0] != y.size:
+            raise ValueError("Mismatch between samples and labels")
 
         # Find last layer - last outsize is num classes
         for layer in reversed(self.layers):

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/neuralnetworknumpy/utils.py

@@ -18,8 +18,12 @@ class History:
 class Scaler:
     def __init__(self, mode="standard"):
         """
-        mode: "standard" for Z-score (Mean=0, Std=1)
-              "minmax" for range scaling (0 to 1)
+        mode: "standard" — Z-score normalisation (mean=0, std=1 per feature)
+              "minmax"   — scales each feature to [0, 1]
+
+        Works with any row-major input shape:
+          (N, features)        — dense / flattened data
+          (N, H, W, channels)  — image data (statistics per pixel-channel)
         """
         self.mode = mode
         self.mean = None
@@ -28,15 +32,17 @@ class Scaler:
         self.max = None
 
     def fit(self, X):
-        """Calculates parameters from training data. X shape: (features, samples)"""
+        """Compute statistics from X. Call only on training data."""
         if self.mode == "standard":
-            self.mean = np.mean(X, axis=1, keepdims=True)
-            self.std = np.std(X, axis=1, keepdims=True)
+            # mean/std shape: (1, features) or (1, H, W, C)
+            # keepdims=True lets them broadcast against any (N, ...) input
+            self.mean = np.mean(X, axis=0, keepdims=True)
+            self.std = np.std(X, axis=0, keepdims=True)
             self.std[self.std == 0] = 1e-8  # Avoid division by zero
 
         elif self.mode == "minmax":
-            self.min = np.min(X, axis=1, keepdims=True)
-            self.max = np.max(X, axis=1, keepdims=True)
+            self.min = np.min(X, axis=0, keepdims=True)
+            self.max = np.max(X, axis=0, keepdims=True)
             # Avoid division by zero if all values in a feature are the same
             self.diff = self.max - self.min
             self.diff[self.diff == 0] = 1e-8
@@ -47,40 +53,52 @@ class Scaler:
             return (X - self.mean) / self.std
         elif self.mode == "minmax":
             return (X - self.min) / self.diff
-        else:
-            raise NotImplementedError
+        raise NotImplementedError(f"Unknown mode: {self.mode}")
 
     def fit_transform(self, X):
+        """Fit on X, then transform and return it. Use only on training data."""
         self.fit(X)
         return self.transform(X)
 
 def split_train_test(X, y, test_ratio=0.2):
-  m = X.shape[1]
+  """
+    Randomly split (X, y) into train and test sets.
+    X shape: (N, ...)  -  any row-major layout.
+    Returns: X_train, y_train, X_test, y_test
+  """
+  m = X.shape[0]
   perm = np.random.permutation(m)
 
-  X = X[:, perm]
+  X = X[perm]
   y = y[perm]
 
   test_size = int(m * test_ratio)
 
-  X_test = X[:, :test_size]
+  X_test = X[:test_size]
   y_test = y[:test_size]
 
-  X_train = X[:, test_size:]
+  X_train = X[test_size:]
   y_train = y[test_size:]
 
   return X_train, y_train, X_test, y_test
 
 
 def split_train_validation(X, y, val_ratio=0.2):
+    """
+        Randomly split (X, y) into train and validation sets.
+        X shape: (N, ...)  -  any row-major layout.
+        Returns: X_train, y_train, X_val, y_val
+    """
     m = X.shape[0]
     perm = np.random.permutation(m)
     X = X[perm]
     y = y[perm]
 
     val_size = int(m * val_ratio)
+
     X_val = X[:val_size]
     y_val = y[:val_size]
+
     X_train = X[val_size:]
     y_train = y[val_size:]
 

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/neuralnetworknumpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuralnetworknumpy
-Version: 0.2.0
+Version: 0.2.1
 Summary: A neural network framework built completely from scratch using NumPy
 Author: Itamar Senderovitz
 License: MIT

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuralnetworknumpy"
-version = "0.2.0"
+version = "0.2.1"
 description = "A neural network framework built completely from scratch using NumPy"
 readme = "README.md"
 requires-python = ">=3.8"

{neuralnetworknumpy-0.2.0 → neuralnetworknumpy-0.2.1}/tests/test_model.py

@@ -35,10 +35,6 @@ test_X = scaler.fit_transform(test_X)
 # Split into training and validation
 train_X, train_y, val_X, val_y = split_train_validation(train_X, train_y, 0.1)
 
-# Transpose to match network input (features, samples)
-train_X = train_X.T  # (784, 54000)
-val_X   = val_X.T    # (784, 6000)
-test_X  = test_X.T   # (784, 10000)
 
 print("Train X:", train_X.shape, "Train y:", train_y.shape)
 print("Validation X:", val_X.shape, "Validation y:", val_y.shape)
@@ -54,9 +50,9 @@ model.save("model.h5")
 print(f"Training time: {time.time() - start_time}")
 
 
-idx = np.random.randint(test_X.shape[1])   # random sample index
+idx = np.random.randint(test_X.shape[0])   # random sample index
 
-x = test_X[:, idx:idx+1]    # shape (784, 1)
+x = test_X[idx:idx+1]    # shape (1, 784)
 y_true = test_y[idx]
 
 y_pred = model.predict(x)