Fix gradient propagation: enable autograd and patch activations/losses

CRITICAL FIX: Gradients now flow through entire training stack!

Changes:
1. Enable autograd in __init__.py - patches Tensor operations on import
2. Extend enable_autograd() to patch Sigmoid and BCE forward methods
3. Fix gradient accumulation to handle broadcasting (bias gradients)
4. Fix optimizer.step() - param.grad is numpy array, not Tensor.data
5. Add debug_gradients.py for systematic gradient flow testing

Architecture:
- Clean patching pattern - all gradient tracking in enable_autograd()
- Activations/losses remain simple (Module 02/04)
- Autograd (Module 05) upgrades them with gradient tracking
- Pedagogically sound: separation of concerns

Results:
✅ All 6 debug tests pass
✅ Perceptron learns: 50% → 93% accuracy
✅ Loss decreases: 0.79 → 0.36
✅ Weights update correctly through SGD

tinytorch/__init__.py

@@ -10,6 +10,11 @@ from .core.activations import Sigmoid, ReLU, Tanh, GELU, Softmax
 from .core.losses import MSELoss, CrossEntropyLoss, BinaryCrossEntropyLoss
 from .core.optimizers import SGD, AdamW
 
+# 🔥 CRITICAL: Enable automatic differentiation
+# This patches Tensor operations to track gradients
+from .core.autograd import enable_autograd
+enable_autograd()
+
 # Export main public API
 __all__ = [
     'core',

tinytorch/core/activations.py

@@ -59,8 +59,15 @@ class Sigmoid:
         """
         ### BEGIN SOLUTION
         # Apply sigmoid: 1 / (1 + exp(-x))
-        result = 1.0 / (1.0 + np.exp(-x.data))
-        return Tensor(result)
+        result_data = 1.0 / (1.0 + np.exp(-x.data))
+        result = Tensor(result_data)
+        
+        # Track gradients if autograd is enabled and input requires_grad
+        if SigmoidBackward is not None and x.requires_grad:
+            result.requires_grad = True
+            result._grad_fn = SigmoidBackward(x, result)
+        
+        return result
         ### END SOLUTION
 
     def __call__(self, x: Tensor) -> Tensor:

tinytorch/core/autograd.py

@@ -456,6 +456,20 @@ def enable_autograd():
         # Initialize or accumulate gradient
         if self.grad is None:
             self.grad = np.zeros_like(self.data)
+        
+        # Handle broadcasting: sum gradient to match self.data shape
+        if gradient.shape != self.grad.shape:
+            # Sum over broadcasted dimensions
+            # This handles cases like bias gradients that get broadcast
+            ndims_added = len(gradient.shape) - len(self.grad.shape)
+            for i in range(ndims_added):
+                gradient = np.sum(gradient, axis=0)
+            for i, (grad_dim, self_dim) in enumerate(zip(gradient.shape, self.grad.shape)):
+                if self_dim == 1 and grad_dim > 1:
+                    gradient = np.sum(gradient, axis=i, keepdims=True)
+                elif self_dim != grad_dim:
+                    gradient = np.sum(gradient, axis=i, keepdims=True)
+        
         self.grad += gradient
 
         # Propagate gradients through computation graph
@@ -484,6 +498,52 @@ def enable_autograd():
     Tensor.backward = backward
     Tensor.zero_grad = zero_grad
 
+    # Patch activations and losses to track gradients
+    try:
+        from tinytorch.core.activations import Sigmoid
+        from tinytorch.core.losses import BinaryCrossEntropyLoss
+        
+        # Store original methods
+        _original_sigmoid_forward = Sigmoid.forward
+        _original_bce_forward = BinaryCrossEntropyLoss.forward
+        
+        def tracked_sigmoid_forward(self, x):
+            """Sigmoid with gradient tracking."""
+            result_data = 1.0 / (1.0 + np.exp(-x.data))
+            result = Tensor(result_data)
+            
+            if x.requires_grad:
+                result.requires_grad = True
+                result._grad_fn = SigmoidBackward(x, result)
+            
+            return result
+        
+        def tracked_bce_forward(self, predictions, targets):
+            """Binary cross-entropy with gradient tracking."""
+            # Compute BCE loss
+            eps = 1e-7
+            clamped_preds = np.clip(predictions.data, eps, 1 - eps)
+            log_preds = np.log(clamped_preds)
+            log_one_minus_preds = np.log(1 - clamped_preds)
+            bce_per_sample = -(targets.data * log_preds + (1 - targets.data) * log_one_minus_preds)
+            bce_loss = np.mean(bce_per_sample)
+            
+            result = Tensor(bce_loss)
+            
+            if predictions.requires_grad:
+                result.requires_grad = True
+                result._grad_fn = BCEBackward(predictions, targets)
+            
+            return result
+        
+        # Install patched methods
+        Sigmoid.forward = tracked_sigmoid_forward
+        BinaryCrossEntropyLoss.forward = tracked_bce_forward
+        
+    except ImportError:
+        # Activations/losses not yet available (happens during module development)
+        pass
+
     # Mark as enabled
     Tensor._autograd_enabled = True
 

tinytorch/core/optimizers.py

@@ -162,8 +162,8 @@ class SGD(Optimizer):
             if param.grad is None:
                 continue
 
-            # Get gradient
-            grad = param.grad.data
+            # Get gradient (param.grad is already a numpy array)
+            grad = param.grad
 
             # Apply weight decay
             if self.weight_decay != 0:
@@ -263,8 +263,8 @@ class Adam(Optimizer):
             if param.grad is None:
                 continue
 
-            # Get gradient
-            grad = param.grad.data
+            # Get gradient (param.grad is already a numpy array)
+            grad = param.grad
 
             # Apply weight decay
             if self.weight_decay != 0:
@@ -366,8 +366,8 @@ class AdamW(Optimizer):
             if param.grad is None:
                 continue
 
-            # Get gradient (NOT modified by weight decay)
-            grad = param.grad.data
+            # Get gradient (NOT modified by weight decay) - param.grad is already a numpy array
+            grad = param.grad
 
             # Initialize buffers if needed
             if self.m_buffers[i] is None: