挑战项目 A · 手搓一个 mini-torch

import minitorch as mt

model = mt.Sequential(
    mt.Linear(30, 64), mt.ReLU(),
    mt.Linear(64, 1))
loss = mt.BCEWithLogits(model(x), y)
loss.backward()          # ← 你自己实现的！
optimizer.step()

   minitorch/
   ├── Tensor          ← 核心：数据 + 梯度 + 计算图节点
   │     .data         numpy 数组
   │     .grad         梯度
   │     ._backward    这个节点怎么把梯度传给父节点
   │     ._prev        父节点集合
   │
   ├── 运算符重载       __add__ __mul__ __matmul__ ...
   │     每个运算都：① 算结果 ② 记录怎么反传
   │
   ├── backward()      拓扑排序 + 从后往前调用 _backward
   │
   ├── nn.Module       Linear / ReLU / Sequential / Dropout
   ├── 损失函数         MSE / BCEWithLogits / CrossEntropy
   └── optim           SGD / Momentum / Adam

import numpy as np

class Tensor:
    def __init__(self, data, _prev=(), requires_grad=True):
        self.data = np.asarray(data, dtype=np.float64)
        self.grad = np.zeros_like(self.data)
        self._prev = set(_prev)
        self._backward = lambda: None       # 默认叶子节点什么都不做
        self.requires_grad = requires_grad

    def __add__(self, other):
        other = other if isinstance(other, Tensor) else Tensor(other)
        out = Tensor(self.data + other.data, (self, other))
        def _backward():
            # ⭐ 难点：广播的反向 —— 把梯度 sum 回原来的形状
            self.grad += unbroadcast(out.grad, self.data.shape)
            other.grad += unbroadcast(out.grad, other.data.shape)
        out._backward = _backward
        return out

    def __matmul__(self, other):
        out = Tensor(self.data @ other.data, (self, other))
        def _backward():
            self.grad  += out.grad @ other.data.T
            other.grad += self.data.T @ out.grad
        out._backward = _backward
        return out

    def relu(self):
        out = Tensor(np.maximum(0, self.data), (self,))
        def _backward():
            self.grad += out.grad * (self.data > 0)
        out._backward = _backward
        return out

    def backward(self):
        # 拓扑排序：保证调用某节点的 _backward 前，它的所有下游都已算完
        topo, visited = [], set()
        def build(v):
            if v not in visited:
                visited.add(v)
                for p in v._prev: build(p)
                topo.append(v)
        build(self)
        self.grad = np.ones_like(self.data)     # 起点：dloss/dloss = 1
        for node in reversed(topo):
            node._backward()


def unbroadcast(grad, shape):
    """把广播后的梯度还原回原形状 —— 这是最容易写错的地方"""
    while grad.ndim > len(shape):
        grad = grad.sum(axis=0)
    for i, s in enumerate(shape):
        if s == 1:
            grad = grad.sum(axis=i, keepdims=True)
    return grad