bp模糊函数反向传播：从数学原理到PyTorch实战指南

1次阅读

共计 2155 个字符，预计需要花费 6 分钟才能阅读完成。

模糊函数通常用于模拟现实中的不精确测量或平滑处理。假设我们使用高斯模糊函数，其数学表达式为：

$$ f(x) = \frac{1}{\sqrt{2\pi\sigma^2}} e^{-\frac{(x-\mu)^2}{2\sigma^2}} $$

其中 $\mu$ 是均值，$\sigma$ 是标准差。

在深度学习中，我们通常处理的是批量数据。假设输入为 $X \in \mathbb{R}^{B\times C\times H\times W}$，模糊核为 $K \in \mathbb{R}^{k\times k}$，则前向传播可以表示为：

$$ Y = X \ast K $$

其中 $\ast$ 表示卷积操作。

根据链式法则，我们需要计算 $\frac{\partial L}{\partial X}$ 和 $\frac{\partial L}{\partial K}$。对于卷积操作的反向传播，有：

输入梯度：
$$ \frac{\partial L}{\partial X} = \frac{\partial L}{\partial Y} \ast rot180(K) $$
核梯度：
$$ \frac{\partial L}{\partial K} = X \ast \frac{\partial L}{\partial Y} $$

其中 $rot180$ 表示将核旋转 180 度。

完全可控的计算过程
可以针对特定操作进行优化
便于理解底层数学原理

减少编码工作量
框架自动处理复杂的链式法则
内置优化（如内存重用）

简单操作：推荐使用自动微分
复杂 / 自定义操作：可能需要手动实现

import torch
import torch.nn as nn
import torch.nn.functional as F

class BlurFunction(torch.autograd.Function):
    @staticmethod
    def forward(ctx, input, kernel):
        # 保存反向传播需要的变量
        ctx.save_for_backward(input, kernel)

        # 使用 F.conv2d 实现向量化卷积
        # 添加 padding 保持尺寸不变
        padding = kernel.size(-1) // 2
        output = F.conv2d(input, kernel, padding=padding)

        return output

    @staticmethod
    def backward(ctx, grad_output):
        input, kernel = ctx.saved_tensors
        padding = kernel.size(-1) // 2

        # 计算输入梯度
        grad_input = F.conv2d(grad_output, kernel.flip(-1, -2), padding=padding)

        # 计算核梯度
        grad_kernel = F.conv2d(input.transpose(0, 1), grad_output.transpose(0, 1), padding=padding)
        grad_kernel = grad_kernel.sum(dim=1, keepdim=True)

        return grad_input, grad_kernel

# 使用示例
blur = BlurFunction.apply

# 创建高斯模糊核
def create_gaussian_kernel(size=3, sigma=1.0):
    coords = torch.arange(size, dtype=torch.float32) - size//2
    g = torch.exp(-(coords**2)/(2*sigma**2))
    g = g.outer(g)
    return (g / g.sum()).view(1, 1, size, size)

# 测试
input = torch.randn(2, 3, 32, 32, requires_grad=True)
kernel = create_gaussian_kernel(5, 1.0)
output = blur(input, kernel)
loss = output.sum()
loss.backward()