深度学习算法实战指南：从CNN到Transformer的场景选择与代码实现

1. 先搞清楚这些算法到底解决什么问题，再决定从哪开始

如果你刚接触深度学习，看到 CNN、RNN、Transformer、GAN、扩散模型这一堆名词，最容易犯的错就是挨个背原理，结果学完还是不知道什么时候该用哪个。我更建议先按实际问题来分类：

• 处理图像、视频、局部特征明显的网格数据：首选 CNN（卷积神经网络）。它的卷积核能自动提取局部模式，比如边缘、纹理、形状，而且参数共享让计算量大幅降低。常见的图像分类、目标检测、人脸识别，底层都依赖 CNN 或它的变体。

• 处理序列数据，比如文本、语音、时间序列：早期用 RNN（循环神经网络），因为它能记住前面步骤的信息。但普通 RNN 有梯度消失问题，所以后来有了 LSTM、GRU 这类改进型。不过，RNN 系列最大问题是难以并行计算，训练慢。

• 需要长距离依赖和全局建模的序列任务：Transformer 是现在的首选。它的自注意力机制能让每个位置直接关注到序列中任何其他位置，并行度高，适合长文本、机器翻译、语音识别。但计算量随序列长度平方增长，所以超长序列还是要优化。

• 生成新数据，比如图片、音乐、文本：GAN（生成对抗网络）和扩散模型是两类主流思路。GAN 通过生成器和判别器对抗训练，容易模式崩溃，但生成样本质量高；扩散模型通过逐步加噪和去噪，训练更稳定，但生成速度慢。

• 注意力机制不是独立模型，而是一种增强组件：它可以加到 CNN、RNN 或 Transformer 里，让模型动态关注输入中更重要的部分。比如图像描述生成中，生成每个词时让模型关注图片中不同的区域。

这几种算法不是互斥的，实际项目经常组合使用。比如视觉 Transformer（ViT）用 Transformer 结构处理图像，但前期常搭配 CNN 做特征提取；扩散模型生成图像时，底层 UNet 经常用 CNN 或 Transformer 做骨干网络。

所以，先明确你的任务类型：是分类、检测、生成、序列预测还是多模态融合？再选对应算法，而不是反过来从算法找场景。

2. 环境准备：别一上来就装最新版，先保证能复现基础案例

深度学习算法实战最怕环境冲突。很多人直接 pip install tensorflow torch 最新版，结果跑旧代码各种报错。我建议分三步走：

2.1 基础环境隔离

优先用 conda 或 venv 创建独立环境，避免包版本污染。下面是通用起步配置：

# 创建环境（Python 3.8 是兼容性比较好的版本） conda create -n dl-tutorial python=3.8 conda activate dl-tutorial # 安装 PyTorch（根据 CUDA 版本选择，CPU 版去掉 cuxxx） pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 -f https://download.pytorch.org/whl/torch_stable.html # 或 TensorFlow（2.9 左右版本比较稳定） pip install tensorflow==2.9.0 # 公共工具库 pip install numpy matplotlib pandas jupyter scikit-learn

为什么选这些版本？因为大多数经典算法教程和项目代码是在 2022-2023 年写的，用太新的框架可能遇到接口变更。先保证能跑通，再升级。

2.2 硬件资源评估

• CPU 就够了：CNN 的 LeNet、AlexNet 在 MNIST、CIFAR-10 这种小数据集上，CPU 也能几分钟跑完一个 epoch。RNN 处理短文本序列（如情感分析）也不需要 GPU。
• 需要 GPU 的场景：Transformer 大模型、GAN 生成高清图、扩散模型训练。显存至少 6GB 起步，不然 batch size 只能设很小，影响收敛。
• 显存不够怎么办：用梯度累积（accumulate gradients），比如实际 batch size=32，但显存放不下，就设 batch size=8，累积 4 步再更新参数。或者用混合精度训练（torch.cuda.amp），减少显存占用。

2.3 数据准备套路

不管什么算法，数据准备流程都类似：

1. 下载标准数据集：MNIST（手写数字）、CIFAR-10（物体分类）、IMDB（情感分析）、COCO（目标检测）这些是算法验证的基准。
2. 统一预处理：图像缩放到固定尺寸、归一化到 [0,1] 或 [-1,1]；文本分词、建词表、转 ID；序列数据做填充（padding）或截断。
3. 用 DataLoader 封装：支持批量加载、随机打乱、多进程读取。

# PyTorch 示例 from torch.utils.data import DataLoader, TensorDataset dataset = TensorDataset(inputs, labels) dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

新手最容易忽略的是数据划分：训练集、验证集、测试集一定要提前分好，不要用测试集参与任何训练过程，否则指标会虚高。

3. CNN 实战：从手写数字识别到自定义图像分类

CNN 是最好入门的算法，因为图像数据直观，而且模型结构层次清晰。

3.1 最简 CNN 结构拆解

以 LeNet-5 为例（1998 年提出，但原理至今通用）：

• 输入层：28x28 单通道图像（MNIST 数据集）
• 卷积层 C1：5x5 卷积核，输出 6 个特征图 → 提取边缘等低级特征
• 池化层 S2：2x2 最大池化 → 降采样，减少计算量，增加平移不变性
• 卷积层 C3：5x5 卷积，输出 16 个特征图 → 组合低级特征成形状、部件
• 池化层 S4：2x2 最大池化 → 进一步降采样
• 全连接层 C5、F6：展平后接全连接层 → 综合所有特征做分类
• 输出层：10 个节点对应 0-9 数字的概率

为什么卷积层后通常接池化层？一是减少参数防止过拟合，二是让模型对位置变化更鲁棒。但现代网络有时用步长卷积代替池化，因为能保留更多信息。

3.2 用 PyTorch 实现 MNIST 分类

import torch import torch.nn as nn import torch.optim as optim class LeNet(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 6, 5) # 输入通道1, 输出通道6, 卷积核5x5 self.pool = nn.MaxPool2d(2, 2) # 2x2 池化, 步长2 self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 4 * 4, 120) # 展平后尺寸要计算 self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) # 28x28 -> 12x12 x = self.pool(torch.relu(self.conv2(x))) # 12x12 -> 4x4 x = x.view(-1, 16 * 4 * 4) # 展平 x = torch.relu(self.fc1(x)) x = torch.relu(self.fc2(x)) x = self.fc3(x) return x model = LeNet() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练循环 for epoch in range(10): for images, labels in train_loader: outputs = model(images) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step()

关键点：卷积后尺寸变化公式(W - K + 2P)/S + 1（W 输入尺寸，K 卷积核大小，P 填充，S 步长）。如果不确定，可以用x = torch.randn(1, 1, 28, 28)试跑一次，看每层输出形状。

3.3 从 MNIST 迁移到自定义数据集

MNIST 跑通后，很多人卡在自定义数据上。常见问题：

• 图片尺寸不一致：用 torchvision.transforms.Resize 统一缩放到固定大小，比如 224x224。
• 内存不足：如果图片太大、数量多，用 DataLoader 的 num_workers 多进程加载，但不要超过 CPU 核心数。
• 过拟合：加数据增强（随机翻转、旋转、裁剪、颜色抖动），或用 Dropout、权重衰减。

from torchvision import transforms # 训练时的数据增强 train_transform = transforms.Compose([ transforms.Resize(224), transforms.RandomHorizontalFlip(), # 随机水平翻转 transforms.RandomRotation(10), # 随机旋转 ±10 度 transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], # ImageNet 统计值 std=[0.229, 0.224, 0.225]) ]) # 测试时不要增强，只需归一化 test_transform = transforms.Compose([ transforms.Resize(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])

CNN 调参优先级：先调学习率（0.01、0.001、0.0001 试），再调批量大小（32、64、128），最后考虑模型深度。不要一上来就改网络结构。

4. RNN 与 LSTM：处理序列数据的核心思路

RNN 适合有时序关系的任务，比如文本生成、股票预测、语音识别。但普通 RNN 记性差，长序列后面会忘记开头的内容。

4.1 RNN 的梯度消失与 LSTM 的解决方案

RNN 通过循环结构传递隐藏状态，但误差反向传播时，梯度会连乘。如果梯度值小于 1，多次连乘后趋近于 0，导致前面层的参数无法更新。这就是梯度消失。

LSTM（长短期记忆网络）通过三个门控机制解决：

• 遗忘门：决定上一时刻的隐藏状态有多少保留到当前
• 输入门：决定当前输入有多少信息要保存到细胞状态
• 输出门：决定当前细胞状态有多少输出到隐藏状态

门控用 sigmoid 函数（输出 0-1）控制信息流，用 tanh 函数做非线性变换。这样梯度可以更稳定地传播。

4.2 用 LSTM 做文本情感分析

以 IMDB 电影评论分类（正面/负面）为例：

import torch.nn as nn class TextLSTM(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, num_layers): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_dim) self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True, dropout=0.2) self.fc = nn.Linear(hidden_dim, 2) # 二分类 def forward(self, x): # x 形状: (batch_size, seq_length) x = self.embedding(x) # -> (batch_size, seq_length, embed_dim) lstm_out, (hidden, cell) = self.lstm(x) # 取最后一个时间步的输出 out = self.fc(lstm_out[:, -1, :]) return out # 超参数参考 vocab_size = 10000 # 词表大小 embed_dim = 100 # 词向量维度 hidden_dim = 128 # LSTM 隐藏层维度 num_layers = 2 # LSTM 层数 model = TextLSTM(vocab_size, embed_dim, hidden_dim, num_layers)

训练前要把文本转成数字序列，并统一长度（短文本补零，长文本截断）。批量训练时，LSTM 默认处理的是等长序列，所以要用 padding。

from torch.nn.utils.rnn import pad_sequence # 假设 texts 是列表，每个元素是单词 ID 的列表 padded_texts = pad_sequence([torch.tensor(t) for t in texts], batch_first=True, padding_value=0)

LSTM 容易过拟合文本数据，解决方法：

• 用 Dropout（LSTM 的 dropout 参数控制层间 dropout）
• 加权重衰减（AdamW 优化器）
• 早停（验证集指标不再提升时停止训练）

4.3 RNN 的局限与 Transformer 的崛起

RNN 系列最大问题是无法并行计算。必须按顺序处理序列，第 t 步依赖第 t-1 步的结果。这在训练时效率低。

Transformer 用自注意力机制取代循环，所有位置同时计算，训练速度快，但推理时如果序列长，内存占用大。所以短序列任务（如机器翻译）用 Transformer 优势明显，超长序列（如文档分类）可能还是 LSTM 更节省资源。

5. Transformer 详解：从序列建模到多模态基础

Transformer 最初为机器翻译设计，但现在已是 NLP、CV 甚至多模态的基石。核心是自注意力（Self-Attention），让模型自己学习哪些位置更重要。

5.1 自注意力机制的计算过程

自注意力输入是序列中每个词的向量，输出是加权后的新向量。计算分三步：

1. 生成 Q、K、V：对每个输入向量，通过三个线性层生成查询（Query）、键（Key）、值（Value）。
2. 计算注意力分数：Q 和 K 点积，度量每个词对其他词的相关性。
3. 加权求和：用 softmax 把分数归一化成权重，对 V 加权求和。

公式：
Attention(Q, K, V) = softmax(QK^T / √d_k) V

除以 √d_k 是为了防止点积过大导致 softmax 梯度太小。实际中常用多头注意力，即把 Q、K、V 拆成多组，分别计算后再拼接，让模型关注不同方面的信息。

5.2 用 PyTorch 实现简化版 Transformer

Transformer 完整结构包含编码器（Encoder）和解码器（Decoder），但很多任务只用编码器（如 BERT）或只用解码器（如 GPT）。下面实现一个编码器用于文本分类：

import torch.nn as nn import torch.nn.functional as F class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() self.d_model = d_model self.num_heads = num_heads self.head_dim = d_model // num_heads self.wq = nn.Linear(d_model, d_model) # 查询变换 self.wk = nn.Linear(d_model, d_model) # 键变换 self.wv = nn.Linear(d_model, d_model) # 值变换 self.fc = nn.Linear(d_model, d_model) # 输出变换 def forward(self, x): batch_size, seq_len, d_model = x.shape Q = self.wq(x).view(batch_size, seq_len, self.num_heads, self.head_dim) K = self.wk(x).view(batch_size, seq_len, self.num_heads, self.head_dim) V = self.wv(x).view(batch_size, seq_len, self.num_heads, self.head_dim) # 计算注意力分数 scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.head_dim ** 0.5) attn_weights = F.softmax(scores, dim=-1) # 加权求和 context = torch.matmul(attn_weights, V) context = context.transpose(1, 2).contiguous().view( batch_size, seq_len, d_model) output = self.fc(context) return output class TransformerEncoderLayer(nn.Module): def __init__(self, d_model, num_heads, ff_dim, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, num_heads) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.ffn = nn.Sequential( nn.Linear(d_model, ff_dim), nn.ReLU(), nn.Linear(ff_dim, d_model) ) self.dropout = nn.Dropout(dropout) def forward(self, x): # 自注意力 + 残差连接 + 层归一化 attn_out = self.self_attn(x) x = self.norm1(x + self.dropout(attn_out)) # 前馈网络 + 残差连接 + 层归一化 ffn_out = self.ffn(x) x = self.norm2(x + self.dropout(ffn_out)) return x

Transformer 训练关键点：

• 位置编码：因为自注意力没有顺序信息，需要额外加位置编码（正弦余弦或可学习参数）。
• 层归一化：放在残差连接后面，稳定训练。
• 学习率预热：开始几轮用较小学习率，再逐步增加到设定值，避免震荡。

5.3 Transformer 在视觉任务中的应用

Vision Transformer（ViT）把图像切分成 16x16 的图块，每个图块展成向量，加上位置编码后输入 Transformer。但在数据量少时，ViT 效果不如 CNN，因为 CNN 有平移不变性等归纳偏置。大数据下 ViT 潜力更大。

Swin Transformer 引入局部窗口注意力，计算量随图像尺寸线性增长，适合高分辨率图像。现在检测、分割模型很多基于 Swin。

6. GAN 与扩散模型：两种生成路径的对比

生成模型的目标是学习数据分布，并生成新样本。GAN 和扩散模型是两种主流思路，各有适用场景。

6.1 GAN 的对抗训练原理

GAN 包含生成器（Generator）和判别器（Discriminator）：

• 生成器：输入随机噪声，输出假样本
• 判别器：输入真样本或假样本，输出为真的概率

训练时，生成器尽量生成以假乱真的样本骗过判别器；判别器尽量区分真假。两者博弈达到平衡时，生成器能产出高质量样本。

但 GAN 训练不稳定，常见问题：

• 模式崩溃：生成器只生成几种样本，缺乏多样性
• 梯度消失：判别器太强，生成器学不到有效梯度
• 超参数敏感：学习率、网络结构微调影响大

改进方案：WGAN（用 Wasserstein 距离代替原始损失）、WGAN-GP（加梯度惩罚）、StyleGAN（控制生成属性）。

6.2 扩散模型的逐步去噪过程

扩散模型分前向和反向两个过程：

• 前向过程：逐步给图像加高斯噪声，最终变成纯噪声
• 反向过程：训练神经网络从噪声中逐步还原出原图

相比 GAN，扩散模型训练更稳定，但生成速度慢（需要多步采样）。DDPM（去噪扩散概率模型）是基础版本，DDIM（隐式扩散模型）加速采样，Stable Diffusion 在潜在空间操作，大幅降低计算量。

6.3 用 PyTorch 实现简单 GAN

以下用全连接网络实现 MNIST 生成：

class Generator(nn.Module): def __init__(self, latent_dim): super().__init__() self.model = nn.Sequential( nn.Linear(latent_dim, 128), nn.ReLU(), nn.Linear(128, 256), nn.ReLU(), nn.Linear(256, 512), nn.ReLU(), nn.Linear(512, 28*28), nn.Tanh() # 输出缩放到 [-1, 1] ) def forward(self, z): img = self.model(z) return img.view(-1, 1, 28, 28) class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Linear(28*28, 512), nn.LeakyReLU(0.2), nn.Linear(512, 256), nn.LeakyReLU(0.2), nn.Linear(256, 1), nn.Sigmoid() # 输出为真的概率 ) def forward(self, img): flattened = img.view(-1, 28*28) validity = self.model(flattened) return validity # 训练循环 generator = Generator(latent_dim=100) discriminator = Discriminator() g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0002) d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0002) for epoch in range(epochs): for real_imgs, _ in dataloader: # 训练判别器 z = torch.randn(real_imgs.size(0), 100) fake_imgs = generator(z) real_loss = torch.log(discriminator(real_imgs)).mean() fake_loss = torch.log(1 - discriminator(fake_imgs.detach())).mean() d_loss = - (real_loss + fake_loss) # 原始 GAN 损失 d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() # 训练生成器 g_loss = - torch.log(discriminator(fake_imgs)).mean() g_optimizer.zero_grad() g_loss.backward() g_optimizer.step()

GAN 训练技巧：

• 判别器不要训得太强，否则生成器梯度消失
• 用 Adam 优化器，学习率一般设 0.0002
• 监控生成样本质量，及时调整超参数

7. 注意力机制：让模型学会关注重点

注意力机制最初用于机器翻译的编码器-解码器结构，让解码器在生成每个词时关注源句子中相关的词。现在已扩展到自注意力、交叉注意力等多种形式。

7.1 注意力在 seq2seq 中的应用

传统 seq2seq 用 RNN 编码整个输入序列为固定长度向量，信息瓶颈明显。加入注意力后，解码器每一步计算对编码器所有输出的注意力权重，动态生成上下文向量。

class Attention(nn.Module): def __init__(self, enc_dim, dec_dim): super().__init__() self.attn = nn.Linear(enc_dim + dec_dim, dec_dim) self.v = nn.Linear(dec_dim, 1, bias=False) def forward(self, hidden, encoder_outputs): # hidden: (batch_size, dec_dim) # encoder_outputs: (batch_size, seq_len, enc_dim) seq_len = encoder_outputs.shape[1] hidden = hidden.unsqueeze(1).repeat(1, seq_len, 1) # 扩增维度匹配 energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim=2))) attention_scores = self.v(energy).squeeze(2) # (batch_size, seq_len) return F.softmax(attention_scores, dim=1) # 归一化成权重

7.2 自注意力与 Transformer 的关系

自注意力是注意力机制的特例：Q、K、V 都来自同一输入。Transformer 完全基于自注意力，摆脱了 RNN 的序列依赖，并行度高。

多头注意力相当于多个自注意力的集成，每个头关注不同特征子空间。比如在机器翻译中，一个头可能关注语法结构，另一个头关注语义内容。

7.3 注意力在视觉任务中的应用

视觉注意力让模型关注图像中重要区域。比如图像描述生成中，生成每个词时模型会聚焦于图片中相关的物体或区域。

通道注意力（如 SENet）学习每个通道的重要性，空间注意力学习每个位置的重要性。CBAM 结合两者，先通道后空间，提升特征表示能力。

8. 项目实战：从算法选择到完整 pipeline

学完单个算法后，关键是如何组合解决实际问题。以新闻分类为例，演示完整流程：

8.1 问题定义与数据探索

任务：将新闻文本分类到体育、科技、财经等类别。

数据探索步骤：

1. 查看类别分布：是否均衡？不平衡可能需要加权损失或过采样
2. 文本长度统计：决定序列最大长度，避免过多填充或截断
3. 检查缺失值和异常样本

8.2 算法选型依据

• 如果文本短（如标题），用 CNN 提取局部特征足够
• 如果文本长且有时序关系（如正文），用 LSTM 或 Transformer
• 如果数据量小，优先选简单模型（CNN、浅层 LSTM）防止过拟合
• 如果数据量大，可以用 BERT 等预训练模型微调

8.3 完整训练 pipeline

import pandas as pd from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score # 1. 数据加载与预处理 df = pd.read_csv('news.csv') texts = df['content'].values labels = df['category'].values # 2. 文本转序列 tokenizer = Tokenizer(num_words=10000) tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts) padded_sequences = pad_sequences(sequences, maxlen=200) # 3. 划分数据集 X_train, X_test, y_train, y_test = train_test_split( padded_sequences, labels, test_size=0.2, random_state=42) # 4. 模型选择与训练 model = TextLSTM(vocab_size=10000, embed_dim=100, hidden_dim=128, num_layers=2, output_dim=len(set(labels))) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() # 5. 训练循环 for epoch in range(10): model.train() for batch_x, batch_y in train_loader: outputs = model(batch_x) loss = criterion(outputs, batch_y) optimizer.zero_grad() loss.backward() optimizer.step() # 6. 验证 model.eval() with torch.no_grad(): test_outputs = model(X_test) test_preds = torch.argmax(test_outputs, dim=1) acc = accuracy_score(y_test, test_preds.numpy()) print(f'Epoch {epoch}, Test Acc: {acc:.4f}')

8.4 模型优化与部署

训练完成后还要考虑：

• 模型压缩：知识蒸馏、剪枝、量化，减少推理时间
• 部署方式：ONNX 格式跨平台、TensorRT 加速、Web API 封装
• 监控更新：线上效果监控、数据分布变化检测、定期重新训练

9. 常见问题排查：从报错信息到解决方案

深度学习项目 80% 时间花在调试上。以下是典型问题排查顺序：

9.1 模型不收敛

• 检查数据：输入输出是否对应？标签是否正确？数据增强是否过度？
• 检查损失函数：二分类用 BCEWithLogitsLoss，多分类用 CrossEntropyLoss，回归用 MSELoss
• 调整学习率：太大震荡，太小下降慢。用学习率查找器（如 torch-lr-finder）或学习率预热
• 检查梯度：用torch.nn.utils.clip_grad_norm_裁剪梯度，防止爆炸

9.2 过拟合

• 增加数据：数据增强、收集更多样本
• 简化模型：减少层数、神经元数
• 正则化：Dropout、权重衰减、早停
• 交叉验证：确保评估指标可靠

9.3 显存不足

• 减小批量大小：最直接有效的方法
• 使用梯度累积：小批量多次前向后向，累积梯度再更新
• 混合精度训练：用 torch.cuda.amp 自动管理 FP16/FP32
• 检查内存泄漏：长时间训练时注意张量累积，及时释放无用变量

9.4 推理速度慢

• 模型优化：剪枝、量化、知识蒸馏
• 硬件加速：TensorRT、OpenVINO、Core ML
• 批量推理：一次处理多个样本，充分利用并行计算
• 缓存结果：静态数据预处理结果保存，避免重复计算

10. 算法选型指南：什么场景用什么方案

最后总结一下核心算法的适用场景：

选型时还要考虑：

• 数据量：大数据用复杂模型，小数据用简单模型或迁移学习
• 计算资源：GPU 内存、训练时间、推理延迟限制
• 可解释性：医疗、金融等领域可能需要更可解释的模型
• 维护成本：复杂模型更新、监控、调试成本更高

实际项目中，通常不是单一算法，而是多个组件组合。比如视觉问答系统可能用 CNN 提取图像特征，LSTM 或 Transformer 处理问题，注意力机制融合多模态信息。

最重要的不是记住所有算法细节，而是理解每种算法的核心思想和适用边界，遇到新问题时能快速选出合适的技术路线。先跑通基线模型，再逐步优化，比一开始就追求最先进方案更实际。