用deepseek学大模型06-前馈神经网络（FFNN）

wyg_031113

952人浏览 · 2025-02-17 11:32:15

wyg_031113 · 2025-02-17 11:32:15 发布

deepseek.com:前馈神经网络的目标函数，损失函数，梯度下降标量和矩阵形式的数学推导，pytorch真实能跑的代码案例以及模型图在tensorboard中的展示，分析应用场景和优缺点，及如何改进解决及改进方法数据推导。

前馈神经网络（FFNN）完整解析

一、数学推导（标量 + 矩阵形式）

1. 前向传播

以3层网络（输入层 → 隐藏层 → 输出层）为例，定义符号：

输入数据： $\in \mathbb{R}^{d \times N}$ （ $d$ 为特征维度， $N$ 为样本数）
权重矩阵： $W_1 \in \mathbb{R}^{h \times d}$ , $W_2 \in \mathbb{R}^{c \times h}$
偏置向量： $b_1 \in \mathbb{R}^h$ , $b_2 \in \mathbb{R}^c$
激活函数： $\sigma(\cdot)$ （如ReLU）

标量形式（单个样本 $x_i$ ）：
$\begin{aligned} z^{(1)}_i &= W_1 x_i + b_1 \\ a^{(1)}_i &= \sigma(z^{(1)}_i) \\ z^{(2)}_i &= W_2 a^{(1)}_i + b_2 \\ \hat{y}_i &= \text{softmax}(z^{(2)}_i) \quad (\text{分类任务}) \end{aligned}$

矩阵形式（批量数据）：
$\begin{aligned} Z_1 &= W_1 X + b_1 \mathbf{1}_N^T \\ A_1 &= \sigma(Z_1) \\ Z_2 &= W_2 A_1 + b_2 \mathbf{1}_N^T \\ \hat{Y} &= \text{softmax}(Z_2) \end{aligned}$
（其中 $\mathbf{1}_N$ 是长度为 $N$ 的全1向量）

2. 目标函数与损失函数

交叉熵损失（分类任务）：
$-\frac{1}{N} \sum_{i=1}^N \sum_{k=1}^c y_{i,k} \log \hat{y}_{i,k} \quad \text{(标量形式)}$
$-\frac{1}{N} \text{Tr}(Y^T \log \hat{Y}) \quad \text{(矩阵形式)}$
（ $Y$ 为one-hot编码标签矩阵）
均方误差（回归任务）：
$\frac{1}{2N} \sum_{i=1}^N \| y_i - \hat{y}_i \|^2 \quad \text{(标量形式)}$
$\frac{1}{2N} \| Y - \hat{Y} \|_F^2 \quad \text{(矩阵形式)}$

3. 梯度下降推导

反向传播（矩阵形式）：

输出层梯度：
$\frac{\partial L}{\partial Z_2} = \frac{1}{N} (\hat{Y} - Y) \quad (\text{交叉熵损失})$
$\frac{\partial L}{\partial W_2} = \frac{\partial L}{\partial Z_2} A_1^T, \quad \frac{\partial L}{\partial b_2} = \frac{\partial L}{\partial Z_2} \mathbf{1}_N$
隐藏层梯度：
$\frac{\partial L}{\partial Z_1} = (W_2^T \frac{\partial L}{\partial Z_2}) \odot \sigma'(Z_1)$
$\frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial Z_1} X^T, \quad \frac{\partial L}{\partial b_1} = \frac{\partial L}{\partial Z_1} \mathbf{1}_N$

二、PyTorch代码实现（含TensorBoard可视化）

1. 数据准备与模型定义

import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter
from sklearn.datasets import make_moons

# 生成非线性数据
X, y = make_moons(n_samples=1000, noise=0.1)
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.long)

# 定义模型
class FFNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(2, 64)
        self.fc2 = nn.Linear(64, 2)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        return self.fc2(x)

model = FFNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

2. 训练与TensorBoard记录

writer = SummaryWriter('runs/ffnn_experiment')

# 记录模型图
dummy_input = torch.randn(1, 2)  # 输入示例
writer.add_graph(model, dummy_input)

# 训练循环
for epoch in range(1000):
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

    # 记录损失
    writer.add_scalar('Loss/train', loss.item(), epoch)
    
    if epoch % 100 == 0:
        print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

writer.close()

在终端运行：

tensorboard --logdir=runs

3. 可视化输出

TensorBoard中将显示：

模型计算图
训练损失曲线

三、应用场景与优缺点分析

应用场景

场景类型	典型任务	数据示例
表格数据分类	客户流失预测	CSV结构化数据
简单图像分类	MNIST手写数字识别	28x28灰度图像
数值预测	股票价格预测	时间序列数据

优缺点对比

优点	缺点
① 结构简单，易于实现	① 全连接层参数量大，计算成本高
② 通用性强（万能近似定理）	② 难以处理空间数据（需CNN）
③ 可解释性（特征权重可视化）	③ 梯度消失/爆炸问题

四、改进方法与数学推导

1. 权重正则化（L2正则化）

数学推导：

修改损失函数：
$L_{\text{reg}} = L + \frac{\lambda}{2} (\|W_1\|_F^2 + \|W_2\|_F^2)$
梯度更新：
$\frac{\partial L_{\text{reg}}}{\partial W_l} = \frac{\partial L}{\partial W_l} + \lambda W_l$

PyTorch实现：

optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)

2. 批量归一化（BatchNorm）

数学形式：
$\hat{z}^{(l)} = \frac{z^{(l)} - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}, \quad y^{(l)} = \gamma \hat{z}^{(l)} + \beta$

PyTorch实现：
```
self.bn = nn.BatchNorm1d(64)
```

3. 残差连接（ResNet思想）

数学形式：
$a^{(l+1)} = \sigma(W_l a^{(l)} + b_l) + a^{(l)}$

PyTorch实现：

class ResidualBlock(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.fc = nn.Linear(dim, dim)
        self.bn = nn.BatchNorm1d(dim)
    
    def forward(self, x):
        return x + self.bn(self.fc(x))

五、核心问题解决方案

问题类型	改进方法	数学原理	PyTorch实现示例
过拟合	Dropout	训练时随机屏蔽神经元	`nn.Dropout(0.5)`
梯度消失	残差连接	恒等映射保留原始信号	见上方ResidualBlock代码
训练不稳定	批量归一化	标准化层输入分布	`nn.BatchNorm1d()`
局部最优	学习率衰减	动态调整搜索步长	`torch.optim.lr_scheduler`

六、扩展实验建议

超参数调优：

# 使用Optuna自动调参
import optuna
def objective(trial):
    lr = trial.suggest_float('lr', 1e-4, 1e-2)
    hidden_dim = trial.suggest_int('hidden_dim', 32, 256)
    model = FFNN(hidden_dim)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    # ...训练过程...
    return test_loss

模型轻量化：

# 使用模型剪枝
from torch.nn.utils import prune
parameters_to_prune = [(model.fc1, 'weight'), (model.fc2, 'weight')]
prune.global_unstructured(parameters_to_prune, pruning_method=prune.L1Unstructured, amount=0.2)

通过以上内容，您可全面掌握前馈神经网络的核心理论与工程实现，并能针对实际问题进行优化改进。

附mnist图像识别

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
# 定义MLP模型
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # 输入层到隐藏层
        self.fc2 = nn.Linear(128, 10)    # 隐藏层到输出层

    def forward(self, x):
        x = torch.relu(self.fc1(x))  # 激活函数
        x = self.fc2(x)
        return x

# 定义超参数
batch_size = 64
epochs = 5
learning_rate = 0.01

# 准备数据
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 初始化模型、优化器和损失函数
model = MLP()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

writer = SummaryWriter('runs/mnist')

# 记录模型图
dummy_input = torch.randn(1, 784)  # 输入示例
writer.add_graph(model, dummy_input)

# 训练模型
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)  # 展平输入
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        writer.add_scalar('Loss/train', loss.item(), epoch)
    print(f'Epoch {epoch+1}/{epochs}, Loss: {running_loss/len(train_loader):.4f}')

# 测试模型
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
    for data, target in test_loader:
        data = data.view(-1, 28*28)
        output = model(data)
        test_loss += criterion(output, target).item()
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()

test_loss /= len(test_loader.dataset)
accuracy = correct / len(test_loader.dataset)
writer.close()
print(f'Test set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({100. * accuracy:.2f}%)')

#git clone https://github.com/knamdar/data