深度学习十大核心算法实战：CNN、Transformer、GAN与扩散模型对比解析-平芜编程栈

深度学习领域的技术迭代速度令人眼花缭乱，但真正决定项目成败的往往不是最新潮的算法，而是对基础模型本质差异的深刻理解。当你面对图像分类任务时，是选择CNN还是Transformer？处理时序数据时，RNN真的过时了吗？GAN和扩散模型在生成质量上究竟有何本质区别？这些问题背后，是每个深度学习工程师必须跨越的认知鸿沟。

本文不会简单罗列算法原理，而是从工程实践角度，深入剖析CNN、RNN、Transformer、GAN、扩散模型、注意力机制等十大核心算法的适用场景、实现细节和避坑指南。通过完整的项目实战演示，你将掌握如何根据具体任务需求选择合适的模型架构，避免陷入"算法崇拜"的误区。

1. 这篇文章真正要解决的问题

在实际项目开发中，深度学习算法的选择往往面临三个核心痛点：首先是概念混淆，很多开发者对CNN、RNN、Transformer的边界认知模糊；其次是实践脱节，理论理解无法有效转化为可运行的代码；最后是选型困难，面对相似任务时不知道如何评估不同算法的优劣。

本文要解决的正是在有限的计算资源和时间成本下，如何快速建立清晰的算法选型思维框架。无论是计算机视觉、自然语言处理还是生成式AI任务，都需要基于数据特性、计算约束和业务目标做出理性选择。例如，处理图像数据时，CNN的局部连接和权重共享特性使其在计算效率上天然优于全连接网络；而处理长序列数据时，Transformer的自注意力机制相比RNN的序列处理更有优势。

更重要的是，本文将揭示这些算法背后的统一数学原理。你会发现，从CNN的卷积核到Transformer的注意力头，从GAN的对抗训练到扩散模型的去噪过程，本质上都是在解决不同形式的数据表示和学习问题。

2. 基础概念与核心原理

2.1 CNN：计算机视觉的基石

卷积神经网络（CNN）的核心思想是局部连接和权重共享。与传统全连接网络相比，CNN通过卷积核在输入数据上的滑动，有效提取局部特征并大幅减少参数量。这种设计使其特别适合处理图像、视频等网格化数据。

关键组件解析：

卷积层：使用可学习的滤波器提取特征，每个滤波器对应一个特征图
池化层：降低特征图尺寸，增强模型平移不变性
全连接层：将学习到的特征映射到最终输出空间

import torch import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self, num_classes=10): super(SimpleCNN, self).__init__() self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1) self.relu = nn.ReLU() self.pool = nn.MaxPool2d(kernel_size=2, stride=2) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1) self.fc = nn.Linear(64 * 8 * 8, num_classes) # 假设输入为32x32图像 def forward(self, x): x = self.conv1(x) x = self.relu(x) x = self.pool(x) x = self.conv2(x) x = self.relu(x) x = self.pool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x # 模型使用示例 model = SimpleCNN() input_tensor = torch.randn(1, 3, 32, 32) # batch_size=1, channels=3, height=32, width=32 output = model(input_tensor) print(f"输出形状: {output.shape}") # torch.Size([1, 10])

2.2 RNN：序列建模的经典方案

循环神经网络（RNN）通过隐藏状态传递历史信息，使其能够处理变长序列数据。然而，标准RNN存在梯度消失/爆炸问题，这在长序列任务中尤为明显。

RNN变体演进：

LSTM：引入门控机制（输入门、遗忘门、输出门）控制信息流动
GRU：简化版LSTM，只有重置门和更新门，计算效率更高

class SimpleLSTM(nn.Module): def __init__(self, input_size, hidden_size, num_layers, num_classes): super(SimpleLSTM, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, num_classes) def forward(self, x): # 初始化隐藏状态 h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) # 前向传播 out, _ = self.lstm(x, (h0, c0)) out = self.fc(out[:, -1, :]) # 取最后一个时间步的输出 return out # 示例：处理长度为10的序列，每个时间步特征维度为5 model = SimpleLSTM(input_size=5, hidden_size=10, num_layers=2, num_classes=3) input_sequence = torch.randn(1, 10, 5) # batch_size=1, seq_length=10, input_size=5 output = model(input_sequence) print(f"LSTM输出形状: {output.shape}") # torch.Size([1, 3])

2.3 Transformer：注意力机制的革命

Transformer完全基于自注意力机制，摒弃了RNN的序列处理方式，支持并行计算且能捕获长距离依赖关系。其核心是多头注意力机制，允许模型同时关注不同表示子空间的信息。

核心组件深度解析：

自注意力机制：计算序列中每个位置与其他位置的关联度
位置编码：为输入序列添加位置信息，弥补注意力机制的位置不敏感性
前馈网络：对每个位置的特征进行非线性变换

class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super(MultiHeadAttention, self).__init__() assert d_model % num_heads == 0 self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_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, query, key, value, mask=None): batch_size = query.size(0) # 线性变换并分头 Q = self.w_q(query).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) K = self.w_k(key).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) V = self.w_v(value).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) # 计算注意力权重 scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn_weights = torch.softmax(scores, dim=-1) # 应用注意力权重 context = torch.matmul(attn_weights, V) context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) return self.w_o(context) # 使用示例 attention = MultiHeadAttention(d_model=512, num_heads=8) x = torch.randn(1, 10, 512) # batch_size=1, seq_length=10, d_model=512 output = attention(x, x, x) print(f"多头注意力输出形状: {output.shape}") # 保持输入形状

3. 环境准备与前置条件

深度学习项目的成功很大程度上取决于环境的正确配置。以下是进行本文所述算法实践所需的完整环境设置。

3.1 硬件要求与推荐配置

最低配置：

CPU：4核以上，支持AVX指令集
内存：16GB RAM
存储：50GB可用空间（用于数据集和模型缓存）

推荐配置（适合完整项目实践）：

GPU：NVIDIA RTX 3060 12GB或更高（CUDA计算能力7.0+）
内存：32GB RAM
存储：NVMe SSD，500GB可用空间

3.2 软件环境详细配置

# 创建conda环境（推荐） conda create -n dl-tutorial python=3.9 conda activate dl-tutorial # 安装PyTorch（根据CUDA版本选择） # CUDA 11.3版本 pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu113 # 或者CPU版本 pip install torch==1.12.1+cpu torchvision==0.13.1+cpu torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cpu # 安装其他依赖 pip install numpy pandas matplotlib seaborn jupyter notebook pip install scikit-learn opencv-python pillow pip install transformers datasets tensorboard

3.3 环境验证脚本

创建验证脚本确保环境配置正确：

# environment_check.py import torch import torchvision import numpy as np import sklearn print("=== 深度学习环境验证 ===") print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}") if torch.cuda.is_available(): print(f"CUDA版本: {torch.version.cuda}") print(f"GPU设备: {torch.cuda.get_device_name(0)}") print(f"NumPy版本: {np.__version__}") print(f"Scikit-learn版本: {sklearn.__version__}") # 简单模型测试 x = torch.randn(2, 3, 224, 224) model = torchvision.models.resnet18(pretrained=False) output = model(x) print(f"ResNet测试输出形状: {output.shape}") print("环境验证完成！")

运行验证脚本应看到类似输出：

=== 深度学习环境验证 === PyTorch版本: 1.12.1+cu113 CUDA可用: True CUDA版本: 11.3 GPU设备: NVIDIA GeForce RTX 3060 NumPy版本: 1.21.6 Scikit-learn版本: 1.0.2 ResNet测试输出形状: torch.Size([2, 1000]) 环境验证完成！

4. CNN项目实战：图像分类完整流程

4.1 数据集准备与预处理

使用CIFAR-10数据集进行实战，该数据集包含10个类别的60000张32x32彩色图像。

import torch from torchvision import datasets, transforms from torch.utils.data import DataLoader # 数据预处理管道 transform = transforms.Compose([ transforms.RandomHorizontalFlip(), # 数据增强 transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ]) # 加载数据集 train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) # 创建数据加载器 train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4) test_loader = DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=4) # 类别名称 classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

4.2 改进的CNN模型架构

import torch.nn as nn import torch.nn.functional as F class AdvancedCNN(nn.Module): def __init__(self, num_classes=10): super(AdvancedCNN, self).__init__() # 特征提取部分 self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(128, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), ) # 分类器部分 self.classifier = nn.Sequential( nn.Dropout(0.5), nn.Linear(256 * 4 * 4, 512), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(512, num_classes) ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x model = AdvancedCNN() print(f"模型参数量: {sum(p.numel() for p in model.parameters())}")

4.3 训练流程与优化策略

import torch.optim as optim from torch.optim.lr_scheduler import StepLR def train_model(model, train_loader, test_loader, epochs=50): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4) scheduler = StepLR(optimizer, step_size=20, gamma=0.1) train_losses = [] test_accuracies = [] for epoch in range(epochs): # 训练阶段 model.train() running_loss = 0.0 for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() running_loss += loss.item() if batch_idx % 100 == 0: print(f'Epoch: {epoch+1} [{batch_idx * len(data)}/{len(train_loader.dataset)}]' f' Loss: {loss.item():.6f}') # 测试阶段 model.eval() correct = 0 total = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) outputs = model(data) _, predicted = torch.max(outputs.data, 1) total += target.size(0) correct += (predicted == target).sum().item() accuracy = 100 * correct / total test_accuracies.append(accuracy) avg_loss = running_loss / len(train_loader) train_losses.append(avg_loss) print(f'Epoch {epoch+1}: Loss: {avg_loss:.4f}, Test Accuracy: {accuracy:.2f}%') scheduler.step() return train_losses, test_accuracies # 开始训练 train_losses, test_accuracies = train_model(model, train_loader, test_loader, epochs=30)

5. Transformer实战：文本分类任务

5.1 数据预处理与词嵌入

import torch from torchtext.legacy import data from torchtext.legacy import datasets import spacy # 定义字段处理 TEXT = data.Field(tokenize='spacy', lower=True, include_lengths=True) LABEL = data.LabelField(dtype=torch.float) # 加载IMDB电影评论数据集 train_data, test_data = datasets.IMDB.splits(TEXT, LABEL) # 构建词汇表 MAX_VOCAB_SIZE = 25000 TEXT.build_vocab(train_data, max_size=MAX_VOCAB_SIZE, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_) LABEL.build_vocab(train_data) # 创建迭代器 BATCH_SIZE = 64 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') train_iterator, test_iterator = data.BucketIterator.splits( (train_data, test_data), batch_size=BATCH_SIZE, sort_within_batch=True, sort_key=lambda x: len(x.text), device=device)

5.2 Transformer文本分类模型

import torch.nn as nn import math class TransformerClassifier(nn.Module): def __init__(self, vocab_size, embed_dim, num_heads, hidden_dim, num_layers, num_classes, max_length=512, dropout=0.1): super(TransformerClassifier, self).__init__() self.embedding = nn.Embedding(vocab_size, embed_dim) self.pos_encoding = PositionalEncoding(embed_dim, max_length) encoder_layer = nn.TransformerEncoderLayer( d_model=embed_dim, nhead=num_heads, dim_feedforward=hidden_dim, dropout=dropout ) self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers) self.classifier = nn.Linear(embed_dim, num_classes) self.dropout = nn.Dropout(dropout) def forward(self, text, text_lengths): # text形状: [seq_len, batch_size] embedded = self.embedding(text) * math.sqrt(self.embedding.embedding_dim) embedded = self.pos_encoding(embedded) # Transformer需要处理填充的mask src_key_padding_mask = self.create_mask(text) encoded = self.transformer_encoder(embedded, src_key_padding_mask=src_key_padding_mask) # 取第一个token的输出作为分类特征 features = encoded[0, :, :] output = self.classifier(self.dropout(features)) return output def create_mask(self, text): # 创建填充mask return (text == 0).transpose(0, 1) class PositionalEncoding(nn.Module): def __init__(self, d_model, max_length=5000): super(PositionalEncoding, self).__init__() pe = torch.zeros(max_length, d_model) position = torch.arange(0, max_length, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0).transpose(0, 1) self.register_buffer('pe', pe) def forward(self, x): return x + self.pe[:x.size(0), :] # 模型实例化 VOCAB_SIZE = len(TEXT.vocab) EMBED_DIM = 100 NUM_HEADS = 5 HIDDEN_DIM = 200 NUM_LAYERS = 3 NUM_CLASSES = 1 # 二分类问题 model = TransformerClassifier(VOCAB_SIZE, EMBED_DIM, NUM_HEADS, HIDDEN_DIM, NUM_LAYERS, NUM_CLASSES)

6. GAN与扩散模型对比实战

6.1 GAN：生成对抗网络实现

import torch import torch.nn as nn import torch.optim as optim import torchvision.utils as vutils class Generator(nn.Module): def __init__(self, latent_dim, img_channels, feature_map_size=64): super(Generator, self).__init__() self.main = nn.Sequential( # 输入: latent_dim维噪声 nn.ConvTranspose2d(latent_dim, feature_map_size * 8, 4, 1, 0, bias=False), nn.BatchNorm2d(feature_map_size * 8), nn.ReLU(True), nn.ConvTranspose2d(feature_map_size * 8, feature_map_size * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size * 4), nn.ReLU(True), nn.ConvTranspose2d(feature_map_size * 4, feature_map_size * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size * 2), nn.ReLU(True), nn.ConvTranspose2d(feature_map_size * 2, feature_map_size, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size), nn.ReLU(True), nn.ConvTranspose2d(feature_map_size, img_channels, 4, 2, 1, bias=False), nn.Tanh() ) def forward(self, input): return self.main(input) class Discriminator(nn.Module): def __init__(self, img_channels, feature_map_size=64): super(Discriminator, self).__init__() self.main = nn.Sequential( # 输入: img_channels x 64 x 64 nn.Conv2d(img_channels, feature_map_size, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(feature_map_size, feature_map_size * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size * 2), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(feature_map_size * 2, feature_map_size * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size * 4), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(feature_map_size * 4, feature_map_size * 8, 4, 2, 1, bias=False), nn.BatchNorm2d(feature_map_size * 8), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(feature_map_size * 8, 1, 4, 1, 0, bias=False), nn.Sigmoid() ) def forward(self, input): return self.main(input).view(-1) # GAN训练函数 def train_gan(generator, discriminator, dataloader, num_epochs=50): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 损失函数和优化器 criterion = nn.BCELoss() lr = 0.0002 g_optimizer = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999)) d_optimizer = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999)) fixed_noise = torch.randn(64, 100, 1, 1, device=device) real_label = 1.0 fake_label = 0.0 for epoch in range(num_epochs): for i, (real_images, _) in enumerate(dataloader): batch_size = real_images.size(0) real_images = real_images.to(device) # 训练判别器 discriminator.zero_grad() label = torch.full((batch_size,), real_label, device=device) output = discriminator(real_images) errD_real = criterion(output, label) errD_real.backward() noise = torch.randn(batch_size, 100, 1, 1, device=device) fake_images = generator(noise) label.fill_(fake_label) output = discriminator(fake_images.detach()) errD_fake = criterion(output, label) errD_fake.backward() errD = errD_real + errD_fake d_optimizer.step() # 训练生成器 generator.zero_grad() label.fill_(real_label) output = discriminator(fake_images) errG = criterion(output, label) errG.backward() g_optimizer.step() if i % 100 == 0: print(f'[{epoch}/{num_epochs}][{i}/{len(dataloader)}] ' f'Loss_D: {errD.item():.4f} Loss_G: {errG.item():.4f}')

6.2 扩散模型：去噪扩散概率模型

import torch import torch.nn as nn import numpy as np class DiffusionModel(nn.Module): def __init__(self, image_size, channels=3, timesteps=1000): super(DiffusionModel, self).__init__() self.timesteps = timesteps self.image_size = image_size # 定义噪声调度 self.betas = self.linear_beta_schedule(timesteps) self.alphas = 1. - self.betas self.alphas_cumprod = torch.cumprod(self.alphas, dim=0) self.sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod) self.sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - self.alphas_cumprod) # 噪声预测网络（U-Net架构） self.denoise_net = UNet(channels, channels) def linear_beta_schedule(self, timesteps, beta_start=0.0001, beta_end=0.02): return torch.linspace(beta_start, beta_end, timesteps) def forward(self, x, t): # 前向扩散过程：添加噪声 sqrt_alpha_cumprod = self.sqrt_alphas_cumprod[t].view(-1, 1, 1, 1) sqrt_one_minus_alpha_cumprod = self.sqrt_one_minus_alphas_cumprod[t].view(-1, 1, 1, 1) noise = torch.randn_like(x) noisy_x = sqrt_alpha_cumprod * x + sqrt_one_minus_alpha_cumprod * noise return noisy_x, noise def reverse_process(self, x, t): # 反向去噪过程 predicted_noise = self.denoise_net(x, t) return predicted_noise class UNet(nn.Module): def __init__(self, in_channels, out_channels): super(UNet, self).__init__() # 简化的U-Net架构实现 self.encoder = nn.Sequential( nn.Conv2d(in_channels, 64, 3, padding=1), nn.ReLU(), nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(64, 128, 3, padding=1), nn.ReLU(), nn.Conv2d(128, 128, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), ) self.decoder = nn.Sequential( nn.Conv2d(128, 64, 3, padding=1), nn.ReLU(), nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(), nn.Upsample(scale_factor=2), nn.Conv2d(64, out_channels, 3, padding=1), ) def forward(self, x, t): # 时间步t的嵌入 t_embed = self.get_timestep_embedding(t, x.shape[1]) t_embed = t_embed.view(x.shape[0], -1, 1, 1).expand(-1, -1, x.shape[2], x.shape[3]) x = torch.cat([x, t_embed], dim=1) x = self.encoder(x) x = self.decoder(x) return x def get_timestep_embedding(self, timesteps, dim): # 将时间步转换为正弦嵌入 half_dim = dim // 2 emb = np.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) emb = timesteps.float()[:, None] * emb[None, :] emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) return emb # 扩散模型训练示例 def train_diffusion(model, dataloader, num_epochs=100): optimizer = optim.Adam(model.parameters(), lr=1e-4) for epoch in range(num_epochs): for batch_idx, (images, _) in enumerate(dataloader): optimizer.zero_grad() # 随机选择时间步 t = torch.randint(0, model.timesteps, (images.size(0),), device=images.device) # 前向扩散过程 noisy_images, true_noise = model.forward(images, t) # 预测噪声 predicted_noise = model.reverse_process(noisy_images, t) # 计算损失 loss = nn.MSELoss()(predicted_noise, true_noise) loss.backward() optimizer.step() if batch_idx % 100 == 0: print(f'Epoch [{epoch}/{num_epochs}] Batch [{batch_idx}/{len(dataloader)}] Loss: {loss.item():.4f}')

7. 注意力机制深度解析与实现

7.1 自注意力机制数学原理

自注意力机制的核心是通过查询（Query）、键（Key）、值（Value）三个矩阵的交互计算注意力权重。给定输入序列$X \in \mathbb{R}^{n \times d}$，首先通过线性变换得到Q、K、V矩阵：

$$Q = XW^Q, \quad K = XW^K, \quad V = XW^V$$

注意力权重计算：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

其中$d_k$是键向量的维度，缩放因子$\sqrt{d_k}$用于防止点积过大导致softmax梯度消失。

7.2 多头注意力实现细节

class MultiHeadAttentionDetailed(nn.Module): def __init__(self, d_model, num_heads, dropout=0.1): super(MultiHeadAttentionDetailed, self).__init__() assert d_model % num_heads == 0 self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_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) self.dropout = nn.Dropout(dropout) self.scale = math.sqrt(self.d_k) def forward(self, query, key, value, mask=None): batch_size = query.size(0) # 线性变换 Q = self.w_q(query) # [batch_size, seq_len, d_model] K = self.w_k(key) # [batch_size, seq_len, d_model] V = self.w_v(value) # [batch_size, seq_len, d_model] # 分头处理 Q = Q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) K = K.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) V = V.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) # 计算注意力分数 scores = torch.matmul(Q, K.transpose(-2, -1)) / self.scale # 应用mask（如需要） if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) # 计算注意力权重 attn_weights = torch.softmax(scores, dim=-1) attn_weights = self.dropout(attn_weights) # 应用注意力权重到值向量 context = torch.matmul(attn_weights, V) # 合并多头输出 context = context.transpose(1, 2).contiguous().view( batch_size, -1, self.num_heads * self.d_k) # 最终线性变换 output = self.w_o(context) return output, attn_weights # 注意力机制可视化示例 def visualize_attention(text, model, tokenizer): """ 可视化文本的注意力权重分布 """ tokens = tokenizer.encode(text, return_tensors='pt') with torch.no_grad(): outputs = model(tokens, output_attent