updated code

Author: sanskarmodi8

machine_learning/mini_batch_gradient_descent.py

@@ -5,21 +5,26 @@
 """
 
 import numpy as np
+from typing import Tuple
 
 
 def mini_batch_gradient_descent(
-    X: np.ndarray, y: np.ndarray, lr: float = 0.01, batch_size: int = 16, n_epochs: int = 50
-):
+    feature_matrix: np.ndarray,
+    target_values: np.ndarray,
+    learning_rate: float = 0.01,
+    batch_size: int = 16,
+    n_epochs: int = 50,
+) -> Tuple[np.ndarray, float]:
     """
     Mini-Batch Gradient Descent for linear regression.
 
     Parameters
     ----------
-    X : np.ndarray
+    feature_matrix : np.ndarray
         Feature matrix.
-    y : np.ndarray
+    target_values : np.ndarray
         Target values.
-    lr : float
+    learning_rate : float
         Learning rate.
     batch_size : int
         Size of mini-batches.
@@ -38,28 +43,30 @@ def mini_batch_gradient_descent(
     >>> import numpy as np
     >>> X = np.array([[1],[2],[3],[4]])
     >>> y = np.array([2,4,6,8])
-    >>> w, b = mini_batch_gradient_descent(X, y, lr=0.1, batch_size=2, n_epochs=100)
+    >>> w, b = mini_batch_gradient_descent(X, y, learning_rate=0.1, batch_size=2, n_epochs=100)
     >>> round(w[0], 1)  # slope close to 2
     2.0
     """
-    n_samples, n_features = X.shape
+    n_samples, n_features = feature_matrix.shape
     weights = np.zeros(n_features)
     bias = 0
 
     for _ in range(n_epochs):
         indices = np.random.permutation(n_samples)
-        X_shuffled, y_shuffled = X[indices], y[indices]
-        for start in range(0, n_samples, batch_size):
-            end = start + batch_size
-            X_batch, y_batch = X_shuffled[start:end], y_shuffled[start:end]
-            y_pred = np.dot(X_batch, weights) + bias
-            error = y_pred - y_batch
-            weights -= lr * (X_batch.T @ error) / len(y_batch)
-            bias -= lr * np.mean(error)
+        shuffled_features = feature_matrix[indices]
+        shuffled_targets = target_values[indices]
+        for start_idx in range(0, n_samples, batch_size):
+            end_idx = start_idx + batch_size
+            batch_features = shuffled_features[start_idx:end_idx]
+            batch_targets = shuffled_targets[start_idx:end_idx]
+            predictions = np.dot(batch_features, weights) + bias
+            errors = predictions - batch_targets
+            weights -= learning_rate * (batch_features.T @ errors) / len(batch_targets)
+            bias -= learning_rate * np.mean(errors)
     return weights, bias
 
 
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod()
+    doctest.testmod()