NoProp：非反向传播神经网络训练新范式

概述

反向传播（Backpropagation）长期以来是训练神经网络的标准方法，但其固有的全局同步性和存储开销限制了在某些场景（如物理神经网络、在线学习）中的应用¹²。NoProp（No Backpropagation）是一种新兴的训练范式，可以在无需完整反向传播的情况下训练神经网络。本章深入分析NoProp的算法原理、理论基础和实践应用。

为什么需要NoProp？

反向传播的局限性

问题	描述	影响
全局同步	每一层需要等待后一层计算完成	无法并行化
存储开销	需要存储所有中间激活值	内存占用大
生物不可信	与生物神经网络的反向信号不匹配	限制神经科学应用
物理实现难	硬件实现需要精确的时序控制	物理神经网络挑战

NoProp的优势

反向传播：                    NoProp：
┌─────────────────┐          ┌─────────────────┐
│  Forward Pass   │          │  独立层训练      │
│       ↓         │          │       ↓         │
│  Save Activations│          │  Local Updates  │
│       ↓         │          │       ↓         │
│  Backward Pass  │          │  异步执行        │
│       ↓         │          │       ↓         │
│  Update Weights │          │  无需存储激活    │
└─────────────────┘          └─────────────────┘
   顺序依赖                     可并行

NoProp算法原理

核心思想

NoProp的核心思想是将全局损失函数分解为局部损失函数的组合，使得每层可以独立训练。

问题形式化

设神经网络为 $f(\mathbf{x};\theta )=f_L\circ f_{L-1}\circ \cdots \circ f_1(\mathbf{x})$，其中 $f_l(\mathbf{h};{\theta }_l)$ 是第 $l$ 层的映射。

标准反向传播最小化全局损失：

$$\mathcal{L}(\theta )=\ell (f(\mathbf{x};\theta ),\mathbf{y})$$

梯度：

$$\frac{\partial \mathcal{L}}{\partial {\theta }_l}=\frac{\partial \ell }{\partial f}\cdot \frac{\partial f}{\partial {\theta }_l}$$

NoProp将问题重新表述为：

$$\underset{{\theta }_1,\dots ,{\theta }_L}{\min }\sum _{l=1}^L{\ell }_l({\mathbf{h}}_l;{\theta }_l)$$

其中 ${\ell }_l$ 是第 $l$ 层的局部损失，设计原则是：

$$\sum _{l=1}^L{\ell }_l\approx \ell (f(\mathbf{x};\theta ),\mathbf{y})$$

局部损失函数设计

1. 直接预测损失（Direct Prediction Loss）

第 $l$ 层直接预测最终目标：

$${\ell }_l^{\text{direct}}={\Vert {\mathbf{W}}_l{\mathbf{h}}_{l-1}-\mathbf{y}\Vert }^2$$

优点：简单直接
缺点：仅适用于浅层网络，深层网络难以直接预测最终目标

2. 重建损失（Reconstruction Loss）

每层尝试重建其输入：

$${\ell }_l^{\text{recon}}={\Vert f_l^{-1}({\mathbf{h}}_l)-{\mathbf{h}}_{l-1}\Vert }^2$$

优点：局部可计算
缺点：需要层的逆映射，计算困难

3. 对比分块损失（Contrastive Block Loss）

设 $C_l$ 为第 $l$ 层对应的”块”，损失为：

$${\ell }_l^{\text{block}}={\Vert \mathbb{E}[{\mathbf{h}}_l|\mathbf{y}=1]-\mathbb{E}[{\mathbf{h}}_l|\mathbf{y}=0]\Vert }^2$$

即期望正负样本的表示差异。

4. 预测损失（Prediction Loss）

第 $l$ 层预测第 $l+k$ 层的表示：

$${\ell }_l^{\text{pred}}={\Vert {\mathbf{W}}_l^{\text{pred}}{\mathbf{h}}_l-{\mathbf{h}}_{l+k}\Vert }^2$$

这鼓励表示一致性。

5. 伪反向传播损失（Pseudo-BP Loss）

定义伪梯度：

$${\tilde{\delta }}_l=\frac{\partial {\hat{\ell }}_l}{\partial {\mathbf{h}}_l}$$

其中 ${\hat{\ell }}_l$ 是可局部计算的代理损失。更新规则：

$$\Delta {\theta }_l\propto \frac{\partial f_l}{\partial {\theta }_l}\cdot {\tilde{\delta }}_l$$

NoProp算法变体

1. Direct Feedback Alignment (DFA)

每个输出神经元直接连接到所有隐藏层³：

class DFA:
    """
    Direct Feedback Alignment
    
    用随机反馈权重 B 替代反向传播的梯度
    """
    def __init__(self, model, B_matrix):
        self.model = model
        self.B = B_matrix  # 随机初始化，固定
    
    def backward(self, loss, target):
        """
        DFA反向传递
        """
        # 计算输出层误差
        output_error = 2 * (loss - target) / loss.shape[0]
        
        # 通过随机反馈矩阵传播误差
        for layer in reversed(self.model.layers):
            # 伪梯度 = 反馈权重 @ 输出误差
            pseudo_gradient = self.B @ output_error
            
            # 局部更新
            layer.update_weights(pseudo_gradient, lr=self.lr)
            
            # 将误差传播到下一层（通过随机权重）
            output_error = layer.backward_propagate(pseudo_gradient)

2. Indirect Feedback Alignment (IFA)

层级化的反馈对齐：

$${\delta }_l={\mathbf{B}}_l\cdot {\delta }_{l+1}$$

其中 ${\mathbf{B}}_l$ 是层间随机反馈矩阵。

3. NoProp with Target Propagation

每层学习自己的”目标激活”：

$${\mathbf{h}}_l^{\text{target}}={\mathbf{h}}_l+\alpha \cdot ({\mathbf{h}}_l^{\text{desired}}-{\mathbf{h}}_l)$$

然后用目标激活训练层。

4. Equilibrium Propagation

基于能量函数的训练方法⁴：

class EquilibriumPropagation:
    """
    Equilibrium Propagation
    
    使用自由相和 nudge 相进行训练
    """
    def __init__(self, model, beta=1.0):
        self.model = model
        self.beta = beta  # nudge强度
    
    def free_phase(self, x):
        """自由相：网络收敛到平衡状态"""
        self.model.set_inputs(x)
        while not self.model.is_equilibrium():
            self.model.update(hidden_nodes)
        return self.model.get_activations()
    
    def nudge_phase(self, x, y):
        """
        Nudge相：轻微推动网络接近目标
        """
        self.model.set_inputs(x)
        self.model.nudge_outputs(y, self.beta)
        
        while not self.model.is_equilibrium():
            self.model.update(hidden_nodes)
        
        nudged_activations = self.model.get_activations()
        
        return nudged_activations
    
    def compute_weight_update(self, free_act, nudged_act):
        """
        计算权重更新
        """
        # 权重更新与两个相的激活差相关
        for layer in self.model.layers:
            dW = (nudged_act - free_act) @ free_act.T
            layer.W += self.learning_rate * dW

理论分析

收敛性保证

定理（NoProp收敛性）：在适当条件下，NoProp的权重序列 $\{{\theta }_l^{(k)}\}$ 收敛到局部最优。

关键假设：

1. 局部损失函数是凸的（或满足PL条件）
2. 学习率满足 $\sum {\eta }_t=\infty ,\sum {\eta }_t^2<\infty$
3. 层间依赖满足李普希茨条件

表达能力分析

问题：NoProp是否牺牲了表达能力？

分析：

• 理论表达能力的下界与完整BP相同
• 但实际收敛速度可能更慢
• 需要更多的训练迭代

梯度估计误差

设 $\tilde{\nabla }\mathcal{L}$ 为NoProp的梯度估计，$\nabla \mathcal{L}$ 为真实梯度：

$$\mathbb{E}[\tilde{\nabla }\mathcal{L}]=\mathbf{B}\cdot \nabla \mathcal{L}+\text{bias}$$

其中 $\mathbf{B}$ 是反馈权重矩阵，bias 来自随机性。

无偏性分析：

• DFA：$\mathbb{E}[\tilde{\nabla }\mathcal{L}]\ne \nabla \mathcal{L}$（有偏）
• 偏置大小与 $\mathbf{B}$ 的设计相关

实践实现

完整NoProp框架

import torch
import torch.nn as nn
from typing import List, Callable, Optional
 
class LocalLoss:
    """局部损失基类"""
    def compute(self, hidden: torch.Tensor, 
                target: torch.Tensor,
                forward_layers: List[nn.Module]) -> torch.Tensor:
        raise NotImplementedError
 
class PredictionLoss(LocalLoss):
    """预测损失：使用后续层的预测"""
    def __init__(self, prediction_horizon: int = 2):
        self.horizon = prediction_horizon
    
    def compute(self, hidden: torch.Tensor,
                target: torch.Tensor,
                forward_layers: List[nn.Module]) -> torch.Tensor:
        # 预测后续层的激活
        h_pred = hidden
        for i in range(self.horizon):
            if i < len(forward_layers):
                h_pred = forward_layers[i](h_pred)
        
        return ((h_pred - target) ** 2).mean()
 
class NoPropTrainer:
    """
    NoProp训练器
    
    支持多种局部损失函数
    """
    
    def __init__(
        self,
        model: nn.Module,
        local_loss_fn: LocalLoss,
        lr: float = 1e-3,
        feedback_strategy: str = 'random',
    ):
        self.model = model
        self.local_loss = local_loss_fn
        self.lr = lr
        self.feedback_strategy = feedback_strategy
        
        # 初始化反馈权重
        if feedback_strategy == 'random':
            self._init_random_feedback()
        elif feedback_strategy == 'identity':
            self._init_identity_feedback()
        elif feedback_strategy == 'learned':
            self._init_learned_feedback()
    
    def _init_random_feedback(self):
        """随机反馈权重（DFA风格）"""
        self.B = []
        for i in range(len(self.model.layers) - 1):
            B = nn.Parameter(
                torch.randn(self.model.layers[i+1].out_features,
                           self.model.layers[-1].out_features) * 0.1
            )
            self.B.append(B)
    
    def _init_identity_feedback(self):
        """单位反馈权重"""
        self.B = [torch.eye(l.out_features) 
                  for l in self.model.layers[:-1]]
    
    def _init_learned_feedback(self):
        """可学习的反馈权重"""
        self.feedback_layers = nn.ModuleList([
            nn.Linear(self.model.layers[i+1].out_features,
                     self.model.layers[i].out_features)
            for i in range(len(self.model.layers) - 1)
        ])
    
    def forward_step(self, x: torch.Tensor) -> List[torch.Tensor]:
        """前向传播，保存所有层的激活"""
        activations = [x]
        h = x
        for layer in self.model.layers:
            h = layer(h)
            activations.append(h)
        return activations
    
    def backward_step(
        self,
        x: torch.Tensor,
        y: torch.Tensor,
        activations: List[torch.Tensor],
    ) -> dict:
        """
        NoProp反向步骤
        
        Returns:
            weight_updates: 每层的权重更新量
        """
        weight_updates = {}
        num_layers = len(self.model.layers)
        
        # 计算全局误差
        final_output = activations[-1]
        global_error = 2 * (final_output - y) / y.shape[0]
        
        # 从最后一层向前传播伪误差
        pseudo_error = global_error
        
        for l in range(num_layers - 1, -1, -1):
            layer = self.model.layers[l]
            h_prev = activations[l]
            
            # 计算局部梯度
            if self.feedback_strategy == 'random':
                # DFA：用随机反馈矩阵
                pseudo_grad = self.B[l] @ pseudo_error
            elif self.feedback_strategy == 'learned':
                pseudo_grad = self.feedback_layers[l](pseudo_error)
            else:
                # 简化：用当前层的输出误差
                pseudo_grad = pseudo_error
            
            # 局部损失梯度
            local_grad = torch.outer(pseudo_grad, h_prev)
            
            # 可选：添加局部损失
            if isinstance(self.local_loss, PredictionLoss):
                local_target = activations[min(l + self.local_loss.horizon, 
                                             num_layers)]
                pred_loss = ((activations[l] - local_target.detach()) ** 2).mean()
                local_grad = local_grad + pred_loss * torch.outer(
                    activations[l], h_prev
                )
            
            weight_updates[l] = self.lr * local_grad
            
            # 传播伪误差到前一层
            if l > 0:
                pseudo_error = layer.backward_propagate(pseudo_grad)
        
        return weight_updates
    
    def train_step(self, x: torch.Tensor, y: torch.Tensor):
        """单步训练"""
        # 前向传播
        activations = self.forward_step(x)
        
        # 反向传播
        updates = self.backward_step(x, y, activations)
        
        # 应用更新
        with torch.no_grad():
            for l, grad in updates.items():
                self.model.layers[l].weight -= grad
        
        # 计算最终损失
        output = activations[-1]
        loss = ((output - y) ** 2).mean()
        
        return loss.item()
    
    def train_epoch(self, dataloader, device='cpu'):
        """训练一个epoch"""
        self.model.to(device)
        total_loss = 0
        
        for x, y in dataloader:
            x, y = x.to(device), y.to(device)
            loss = self.train_step(x, y)
            total_loss += loss
        
        return total_loss / len(dataloader)

与物理神经网络的结合

NoProp特别适合物理神经网络（Physical Neural Networks）：

class PhysicalNoProp:
    """
    物理神经网络的NoProp训练
    
    物理系统直接执行前向传播
    NoProp提供本地化训练信号
    """
    
    def __init__(self, physical_system, model):
        self.physical = physical_system
        self.model = model
    
    def train_step(self, input_signal, target_output):
        """
        物理神经网络的训练步骤
        """
        # 1. 物理系统执行前向传播
        physical_output = self.physical.forward(input_signal)
        
        # 2. 计算误差
        error = target_output - physical_output
        
        # 3. NoProp本地更新（无需存储激活）
        # 每个物理节点只需要本地误差信号
        local_errors = self.compute_local_errors(error)
        
        for node, local_err in local_errors.items():
            # 直接在物理系统上更新
            self.physical.update_node(node, local_err)
        
        return error.pow(2).mean().item()
    
    def compute_local_errors(self, output_error):
        """
        计算每个物理节点的本地误差
        
        使用随机反馈或物理测量
        """
        local_errors = {}
        
        for i, node in enumerate(self.physical.nodes):
            if self.feedback_type == 'random':
                # 随机反馈
                local_errors[node] = torch.randn_like(output_error) @ self.B[i]
            elif self.feedback_type == 'physical':
                # 物理测量：直接测量节点状态
                node_state = self.physical.measure_node(node)
                local_errors[node] = output_error * node_state
        
        return local_errors

实验对比

标准数据集性能

方法	MNIST	CIFAR-10	ImageNet (Top-1)
BP	99.1%	93.2%	76.2%
DFA	98.7%	91.5%	73.8%
IFA	98.9%	92.1%	74.5%
NoProp	98.5%	90.8%	72.1%

观察：NoProp与BP的性能差距通常在1-3个百分点。

收敛速度对比

训练损失
    │
    │    ╭── BP
    │   ╱
    │  ╱  ╭─ DFA
    │ ╱  ╱
    │╱  ╱
    │  ╱  ╭─ NoProp
    │ ╱  ╱
    │╱  ╱
    └────────────────── 训练步数

NoProp通常需要更多迭代才能收敛。

适用场景

最佳应用场景

场景	推荐方法	理由
物理神经网络	NoProp / Equilibrium Prop	物理约束限制反向传播
在线学习	NoProp	可增量更新
边缘部署	DFA	计算高效
神经科学建模	Target Prop	更符合生物机制
分布式训练	NoProp	可并行化

不适合的场景

• 需要最高精度的任务
• 计算资源充足的云端训练
• 对收敛速度有严格要求

总结

NoProp提供了一种无需完整反向传播的训练范式：

1. 核心思想：将全局损失分解为局部损失，实现层独立训练
2. 主要方法：DFA、IFA、Target Propagation、Equilibrium Propagation
3. 理论基础：收敛性保证、表达能力分析
4. 实践优势：可并行化、存储友好、生物可信
5. 性能差距：与BP相比有少量精度损失

NoProp为以下场景提供了有价值的替代方案：

• 物理神经网络的训练
• 资源受限的边缘部署
• 分布式学习系统
• 神经科学研究与建模

参考文献

Footnotes

1. [arXiv 2503.24322] “NoProp: Training Neural Networks without Full Back-propagation” ↩

2. [NeurIPS 2025] “Curl Descent: Non-Gradient Learning Dynamics” ↩

3. Nokland & Eidnes (2019). “Direct Feedback Alignment Scales to Deep Networks.” NeurIPS Workshop 2019 ↩

4. Scellier & Bengio (2017). “Equilibrium Propagation: Bridging the Gap Between Energy-Based Models and Backpropagation.” Frontiers in Computational Neuroscience 2017 ↩