神经网络架构

什么是神经网络？

前馈神经网络 (FNN)

前馈神经网络是最基础的神经网络架构。数据从输入层经过一个或多个隐藏层，最终到达输出层，信息单向流动，不存在循环连接。每一层的神经元与下一层全连接（Fully Connected），通过激活函数（如 ReLU、Sigmoid）引入非线性。

FNN 适用于结构化数据的简单分类和回归任务，例如表格数据预测、信用评分等。当数据具有空间结构（图像）或时间序列特性时，应选择 CNN 或 RNN。

关键流程

PyTorch

import torch
import torch.nn as nn

class FNN(nn.Module):
    def __init__(self, in_dim, hidden, out_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.Linear(hidden, out_dim),
        )
    def forward(self, x):
        return self.net(x)

model = FNN(784, 256, 10)  # e.g. MNIST digits

卷积神经网络 (CNN)

CNN 通过卷积核（filter）在输入数据上滑动，自动提取局部特征（边缘、纹理、形状）。卷积层使用权重共享，大幅减少参数量；池化层（Pooling）降低空间维度，增强平移不变性。多层卷积堆叠后，网络能从低级特征（边缘）逐步抽象为高级语义特征（物体部件、完整物体）。

CNN 是计算机视觉的基础架构，从图像分类、目标检测到语义分割均有广泛应用。近年来 Vision Transformer（ViT）在某些任务上超越了 CNN，但 CNN 仍以其高效性和成熟的工具链占据重要地位。

核心组件流程

经典 CNN 模型

PyTorch

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 256),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes),
        )
    def forward(self, x):
        return self.classifier(self.features(x))

RNN / LSTM / GRU

循环神经网络（RNN）专为序列数据设计。每个时间步的隐藏状态 h(t) 既依赖当前输入 x(t)，也依赖上一步的隐藏状态 h(t-1)，从而捕获序列中的时间依赖关系。然而，标准 RNN 在长序列上存在严重的梯度消失/爆炸问题。

LSTM（Long Short-Term Memory）通过引入"遗忘门、输入门、输出门"三个门控机制和独立的记忆单元（cell state），有效解决了长距离依赖问题。GRU（Gated Recurrent Unit）是 LSTM 的简化版本，将遗忘门和输入门合并为"更新门"，参数更少且训练速度更快，在许多任务上效果相当。

RNN vs LSTM vs GRU 对比

PyTorch

import torch.nn as nn

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden, num_classes):
        super().__init__()
        self.emb = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden, num_layers=2,
                            batch_first=True, dropout=0.3)
        self.fc = nn.Linear(hidden, num_classes)

    def forward(self, x):
        x = self.emb(x)                    # (B, T, E)
        _, (h_n, _) = self.lstm(x)          # h_n: (2, B, H)
        out = self.fc(h_n[-1])              # last layer hidden
        return out

Transformer

Transformer 是 2017 年 Google 在论文"Attention Is All You Need"中提出的架构，它完全摒弃了循环结构，仅依靠自注意力机制（Self-Attention）来建模序列中任意位置之间的依赖关系。这使得 Transformer 可以高度并行化训练，解决了 RNN 的顺序瓶颈。

Transformer 的核心是多头注意力机制（Multi-Head Attention）：将输入映射为 Query、Key、Value 三个矩阵，通过缩放点积注意力计算每个位置对其他所有位置的关注权重。位置编码（Positional Encoding）用于注入序列位置信息，因为自注意力本身不感知顺序。

核心公式

架构组成

Transformer 变体

PyTorch — Self-Attention

import torch
import torch.nn as nn
import math

class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.d_k = d_model // n_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, x):
        B, T, C = x.shape
        q = self.W_q(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)
        k = self.W_k(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)
        v = self.W_v(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)

        # Scaled dot-product attention
        attn = (q @ k.transpose(-2,-1)) / math.sqrt(self.d_k)
        attn = torch.softmax(attn, dim=-1)
        out = (attn @ v).transpose(1,2).contiguous().view(B, T, C)
        return self.W_o(out)

# Usage: attn = SelfAttention(d_model=512, n_heads=8)

GAN (生成对抗网络)

GAN 由 Ian Goodfellow 于 2014 年提出，包含两个相互对抗的网络：生成器（Generator）试图从随机噪声生成逼真的数据，判别器（Discriminator）试图区分真实数据和生成数据。两者通过博弈论中的极小极大游戏进行训练，最终生成器能够产生难以分辨的高质量样本。

GAN 的训练不稳定是其主要挑战，容易出现模式崩溃（mode collapse）和训练震荡。WGAN、Spectral Normalization 等技术在一定程度上缓解了这些问题。

GAN 变体

PyTorch — Simple GAN

import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, z_dim=100, img_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(z_dim, 256), nn.LeakyReLU(0.2),
            nn.Linear(256, 512), nn.LeakyReLU(0.2),
            nn.Linear(512, img_dim), nn.Tanh(),
        )
    def forward(self, z):
        return self.net(z)

class Discriminator(nn.Module):
    def __init__(self, img_dim=784):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(img_dim, 512), nn.LeakyReLU(0.2),
            nn.Linear(512, 256), nn.LeakyReLU(0.2),
            nn.Linear(256, 1), nn.Sigmoid(),
        )
    def forward(self, x):
        return self.net(x)

扩散模型 (Diffusion Models)

扩散模型是一类基于概率的生成模型，其核心思想分两步：前向过程（forward process）逐步向数据添加高斯噪声直至变为纯噪声；反向过程（reverse process）学习从噪声中逐步去噪恢复原始数据。通过参数化一个去噪网络（通常是 U-Net 架构），模型学会在每一步预测并移除噪声。

相比 GAN，扩散模型训练更稳定、生成质量更高、多样性更好，但推理速度较慢（需要多步去噪）。DDPM、DDIM 等采样策略可以加速推理过程。

代表性模型

架构综合对比

架构选型指南

根据任务类型选择最合适的神经网络架构：

相关资源

深入了解机器学习和深度学习框架：

常见问题 (FAQ)