在深度学习项目实践中很多开发者都会遇到这样的困惑面对CNN、RNN、Transformer等众多算法不知道如何系统学习更不清楚在实际项目中该如何选择。本文将用最直观的方式带你完整掌握八大核心深度学习算法的原理、实现和应用场景。无论你是刚入门的新手还是有一定基础想系统提升的开发者这套教程都能帮你建立完整的知识体系。我们将从最基础的卷积神经网络开始逐步深入到Transformer等前沿架构每个算法都配有可运行的代码示例和实战项目。1. 深度学习算法概述与学习路线1.1 为什么要学习这八大算法深度学习算法虽然在形式上多样但核心思想都是通过神经网络学习数据中的特征表示。CNN擅长处理网格状数据如图像RNN系列适合序列数据如文本、语音Transformer通过自注意力机制在多个领域取得突破GAN能够生成逼真的数据DQN在强化学习领域表现出色GNN处理图结构数据LSTM解决长序列依赖问题DBN则在无监督学习中有独特优势。掌握这八大算法意味着你能够应对绝大多数实际业务场景从图像识别、自然语言处理到推荐系统、游戏AI等。1.2 学习路线规划建议按照以下顺序系统学习CNN卷积神经网络- 计算机视觉基础RNN循环神经网络- 序列建模入门LSTM长短期记忆网络- 解决RNN长期依赖问题Transformer- 现代NLP的基石GAN生成对抗网络- 生成式模型核心DQN深度Q网络- 强化学习实战GNN图神经网络- 图数据处理DBN深度信念网络- 无监督学习代表每个算法学习周期建议3-5天包括理论理解、代码实现和项目实践。2. 环境准备与工具配置2.1 基础环境要求深度学习开发环境需要具备以下组件Python 3.8推荐3.9或3.10CUDA 11.0GPU加速可选但推荐cuDNN 8.0GPU加速库至少8GB内存16GB以上更佳2.2 核心库安装# 创建虚拟环境 python -m venv dl_tutorial source dl_tutorial/bin/activate # Linux/Mac # dl_tutorial\Scripts\activate # Windows # 安装核心依赖 pip install torch1.13.0cu117 torchvision0.14.0cu117 torchaudio0.13.0 --extra-index-url https://download.pytorch.org/whl/cu117 pip install tensorflow2.11.0 pip install numpy1.21.6 pandas1.3.5 matplotlib3.5.3 seaborn0.11.2 pip install jupyter notebook scikit-learn scipy2.3 开发工具配置推荐使用Jupyter Notebook进行算法学习和实验# 启动Jupyter jupyter notebook # 或者在VS Code中安装Jupyter扩展 # 创建新的.ipynb文件开始实验3. CNN卷积神经网络详解3.1 CNN核心原理卷积神经网络通过局部连接、权值共享和池化操作有效提取图像的空间特征。卷积层负责特征提取池化层进行特征降维全连接层完成分类任务。关键概念理解卷积核特征检测器在不同位置共享参数感受野每个神经元对应的输入区域特征图卷积操作后的输出结果3.2 CNN完整实现示例import torch import torch.nn as nn import torch.nn.functional as F class SimpleCNN(nn.Module): def __init__(self, num_classes10): super(SimpleCNN, self).__init__() self.conv1 nn.Conv2d(1, 32, kernel_size3, padding1) self.conv2 nn.Conv2d(32, 64, kernel_size3, padding1) self.pool nn.MaxPool2d(2, 2) self.fc1 nn.Linear(64 * 7 * 7, 128) self.fc2 nn.Linear(128, num_classes) self.dropout nn.Dropout(0.5) def forward(self, x): x self.pool(F.relu(self.conv1(x))) # 28x28 - 14x14 x self.pool(F.relu(self.conv2(x))) # 14x14 - 7x7 x x.view(-1, 64 * 7 * 7) # 展平 x F.relu(self.fc1(x)) x self.dropout(x) x self.fc2(x) return x # 模型测试 model SimpleCNN() print(f模型参数量: {sum(p.numel() for p in model.parameters())})3.3 CNN实战手写数字识别import torchvision import torchvision.transforms as transforms from torch.utils.data import DataLoader # 数据准备 transform transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) train_dataset torchvision.datasets.MNIST( root./data, trainTrue, downloadTrue, transformtransform) test_dataset torchvision.datasets.MNIST( root./data, trainFalse, downloadTrue, transformtransform) train_loader DataLoader(train_dataset, batch_size64, shuffleTrue) test_loader DataLoader(test_dataset, batch_size64, shuffleFalse) # 训练循环 def train_model(model, train_loader, epochs5): criterion nn.CrossEntropyLoss() optimizer torch.optim.Adam(model.parameters(), lr0.001) for epoch in range(epochs): running_loss 0.0 for i, (images, labels) in enumerate(train_loader): optimizer.zero_grad() outputs model(images) loss criterion(outputs, labels) loss.backward() optimizer.step() running_loss loss.item() if i % 100 99: print(fEpoch {epoch1}, Batch {i1}: Loss {running_loss/100:.4f}) running_loss 0.0 # 开始训练 train_model(model, train_loader)4. RNN循环神经网络深度解析4.1 RNN工作原理循环神经网络通过循环连接处理序列数据每个时间步共享相同的权重参数。这种结构使得RNN能够捕捉序列中的时序依赖关系。RNN的数学表达h_t tanh(W_{hh}h_{t-1} W_{xh}x_t b_h) y_t W_{hy}h_t b_y其中h_t是隐藏状态x_t是输入y_t是输出。4.2 RNN文本分类实战import torch import torch.nn as nn class SimpleRNN(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim, n_layers1): super(SimpleRNN, self).__init__() self.embedding nn.Embedding(vocab_size, embed_dim) self.rnn nn.RNN(embed_dim, hidden_dim, n_layers, batch_firstTrue) self.fc nn.Linear(hidden_dim, output_dim) def forward(self, x): embedded self.embedding(x) # (batch, seq_len, embed_dim) output, hidden self.rnn(embedded) return self.fc(hidden.squeeze(0)) # 示例情感分析任务 vocab_size 10000 # 词汇表大小 embed_dim 100 # 词向量维度 hidden_dim 128 # 隐藏层维度 output_dim 2 # 二分类 model SimpleRNN(vocab_size, embed_dim, hidden_dim, output_dim) # 模拟输入数据batch_size2, seq_len10 input_data torch.randint(0, vocab_size, (2, 10)) output model(input_data) print(f输出形状: {output.shape}) # torch.Size([2, 2])4.3 RNN的梯度问题与解决方案传统RNN面临梯度消失和梯度爆炸问题梯度消失长序列中梯度逐渐变小无法学习长期依赖梯度爆炸梯度指数级增长导致训练不稳定解决方案梯度裁剪限制梯度最大值使用LSTM/GRU等改进结构合适的权重初始化# 梯度裁剪示例 optimizer torch.optim.Adam(model.parameters(), lr0.001) loss criterion(outputs, labels) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm1.0) optimizer.step()5. LSTM长短期记忆网络5.1 LSTM核心机制LSTM通过门控机制解决长期依赖问题包含三个关键门遗忘门决定丢弃哪些信息输入门决定更新哪些信息输出门决定输出哪些信息class LSTMModel(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim, n_layers1): super(LSTMModel, self).__init__() self.lstm nn.LSTM(input_dim, hidden_dim, n_layers, batch_firstTrue) self.fc nn.Linear(hidden_dim, output_dim) def forward(self, x): lstm_out, (hidden, cell) self.lstm(x) return self.fc(hidden[-1]) # 时间序列预测示例 model LSTMModel(input_dim1, hidden_dim50, output_dim1) # 模拟时间序列数据batch_size32, seq_len10, feature_dim1 time_series_data torch.randn(32, 10, 1) prediction model(time_series_data) print(f预测结果形状: {prediction.shape})5.2 LSTM实战股票价格预测import pandas as pd import numpy as np from sklearn.preprocessing import MinMaxScaler class StockPredictor: def __init__(self, sequence_length60): self.sequence_length sequence_length self.scaler MinMaxScaler() def prepare_data(self, prices): 准备LSTM训练数据 scaled_data self.scaler.fit_transform(prices.reshape(-1, 1)) X, y [], [] for i in range(self.sequence_length, len(scaled_data)): X.append(scaled_data[i-self.sequence_length:i, 0]) y.append(scaled_data[i, 0]) return np.array(X), np.array(y) def create_model(self): 创建LSTM预测模型 model nn.Sequential( nn.LSTM(1, 50, batch_firstTrue), nn.Linear(50, 25), nn.ReLU(), nn.Linear(25, 1) ) return model # 使用示例 predictor StockPredictor() # 假设prices是股票价格序列 # X, y predictor.prepare_data(prices)6. Transformer架构原理与实现6.1 Transformer核心组件Transformer基于自注意力机制完全摒弃了循环结构支持并行计算。主要组件包括自注意力机制计算输入序列中每个位置与其他位置的关系位置编码为序列添加位置信息前馈网络每个位置独立进行非线性变换编码器-解码器结构用于序列到序列任务6.2 自注意力机制实现import math import torch import torch.nn as nn 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 scaled_dot_product_attention(self, Q, K, V, maskNone): attn_scores torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: attn_scores attn_scores.masked_fill(mask 0, -1e9) attn_probs torch.softmax(attn_scores, dim-1) output torch.matmul(attn_probs, V) return output def forward(self, Q, K, V, maskNone): batch_size Q.size(0) # 线性变换 分头 Q self.W_q(Q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) K self.W_k(K).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) V self.W_v(V).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) # 自注意力计算 attn_output self.scaled_dot_product_attention(Q, K, V, mask) # 合并多头 线性变换 attn_output attn_output.transpose(1, 2).contiguous().view( batch_size, -1, self.d_model) return self.W_o(attn_output)6.3 Transformer编码器实现class TransformerEncoderLayer(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout0.1): super(TransformerEncoderLayer, self).__init__() self.self_attn MultiHeadAttention(d_model, num_heads) self.feed_forward nn.Sequential( nn.Linear(d_model, d_ff), nn.ReLU(), nn.Linear(d_ff, d_model) ) self.norm1 nn.LayerNorm(d_model) self.norm2 nn.LayerNorm(d_model) self.dropout nn.Dropout(dropout) def forward(self, x, maskNone): # 自注意力子层 attn_output self.self_attn(x, x, x, mask) x self.norm1(x self.dropout(attn_output)) # 前馈网络子层 ff_output self.feed_forward(x) x self.norm2(x self.dropout(ff_output)) return x class PositionalEncoding(nn.Module): def __init__(self, d_model, max_seq_length5000): super(PositionalEncoding, self).__init__() pe torch.zeros(max_seq_length, d_model) position torch.arange(0, max_seq_length, dtypetorch.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) self.register_buffer(pe, pe) def forward(self, x): return x self.pe[:, :x.size(1)]7. GAN生成对抗网络7.1 GAN基本原理生成对抗网络包含两个核心组件生成器(Generator)学习生成逼真数据判别器(Discriminator)区分真实数据和生成数据两者通过对抗训练共同提升最终生成器能够产生以假乱真的数据。7.2 DCGAN实战实现class Generator(nn.Module): def __init__(self, latent_dim, img_channels, features_g64): super(Generator, self).__init__() self.net nn.Sequential( # 输入: latent_dim x 1 x 1 nn.ConvTranspose2d(latent_dim, features_g*8, 4, 1, 0, biasFalse), nn.BatchNorm2d(features_g*8), nn.ReLU(True), # 状态: (features_g*8) x 4 x 4 nn.ConvTranspose2d(features_g*8, features_g*4, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_g*4), nn.ReLU(True), # 状态: (features_g*4) x 8 x 8 nn.ConvTranspose2d(features_g*4, features_g*2, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_g*2), nn.ReLU(True), # 状态: (features_g*2) x 16 x 16 nn.ConvTranspose2d(features_g*2, features_g, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_g), nn.ReLU(True), # 状态: (features_g) x 32 x 32 nn.ConvTranspose2d(features_g, img_channels, 4, 2, 1, biasFalse), nn.Tanh() # 输出: img_channels x 64 x 64 ) def forward(self, x): return self.net(x) class Discriminator(nn.Module): def __init__(self, img_channels, features_d64): super(Discriminator, self).__init__() self.net nn.Sequential( # 输入: img_channels x 64 x 64 nn.Conv2d(img_channels, features_d, 4, 2, 1, biasFalse), nn.LeakyReLU(0.2, inplaceTrue), # 状态: (features_d) x 32 x 32 nn.Conv2d(features_d, features_d*2, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_d*2), nn.LeakyReLU(0.2, inplaceTrue), # 状态: (features_d*2) x 16 x 16 nn.Conv2d(features_d*2, features_d*4, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_d*4), nn.LeakyReLU(0.2, inplaceTrue), # 状态: (features_d*4) x 8 x 8 nn.Conv2d(features_d*4, features_d*8, 4, 2, 1, biasFalse), nn.BatchNorm2d(features_d*8), nn.LeakyReLU(0.2, inplaceTrue), # 状态: (features_d*8) x 4 x 4 nn.Conv2d(features_d*8, 1, 4, 1, 0, biasFalse), nn.Sigmoid() ) def forward(self, x): return self.net(x)7.3 GAN训练技巧def train_gan(generator, discriminator, dataloader, num_epochs50): criterion nn.BCELoss() lr 0.0002 g_optimizer torch.optim.Adam(generator.parameters(), lrlr, betas(0.5, 0.999)) d_optimizer torch.optim.Adam(discriminator.parameters(), lrlr, betas(0.5, 0.999)) for epoch in range(num_epochs): for i, (real_images, _) in enumerate(dataloader): batch_size real_images.size(0) # 训练判别器 d_optimizer.zero_grad() # 真实图像损失 real_labels torch.ones(batch_size, 1) real_output discriminator(real_images) d_loss_real criterion(real_output, real_labels) # 生成图像损失 z torch.randn(batch_size, latent_dim, 1, 1) fake_images generator(z) fake_labels torch.zeros(batch_size, 1) fake_output discriminator(fake_images.detach()) d_loss_fake criterion(fake_output, fake_labels) d_loss d_loss_real d_loss_fake d_loss.backward() d_optimizer.step() # 训练生成器 g_optimizer.zero_grad() output discriminator(fake_images) g_loss criterion(output, real_labels) # 骗过判别器 g_loss.backward() g_optimizer.step() print(fEpoch [{epoch1}/{num_epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f})8. DQN深度Q网络8.1 强化学习基础DQN结合了Q-learning和深度学习用于解决高维状态空间的决策问题。核心思想是用神经网络近似Q值函数。关键概念状态(State)环境的当前情况动作(Action)智能体可以执行的操作奖励(Reward)执行动作后环境的反馈Q值在某个状态下执行某个动作的长期期望回报8.2 DQN算法实现import collections import random class ReplayBuffer: def __init__(self, capacity): self.buffer collections.deque(maxlencapacity) def add(self, state, action, reward, next_state, done): self.buffer.append((state, action, reward, next_state, done)) def sample(self, batch_size): transitions random.sample(self.buffer, batch_size) state, action, reward, next_state, done zip(*transitions) return np.array(state), action, reward, np.array(next_state), done def size(self): return len(self.buffer) class DQN(nn.Module): def __init__(self, state_dim, action_dim): super(DQN, self).__init__() self.fc1 nn.Linear(state_dim, 128) self.fc2 nn.Linear(128, 128) self.fc3 nn.Linear(128, action_dim) def forward(self, x): x F.relu(self.fc1(x)) x F.relu(self.fc2(x)) return self.fc3(x) class DQNAgent: def __init__(self, state_dim, action_dim, lr0.001, gamma0.99, epsilon0.9): self.action_dim action_dim self.q_net DQN(state_dim, action_dim) self.target_net DQN(state_dim, action_dim) self.optimizer torch.optim.Adam(self.q_net.parameters(), lrlr) self.gamma gamma self.epsilon epsilon self.buffer ReplayBuffer(10000) self.count 0 def choose_action(self, state): if np.random.random() self.epsilon: return np.random.randint(self.action_dim) else: state torch.FloatTensor(state).unsqueeze(0) q_values self.q_net(state) return q_values.argmax().item() def update(self, batch_size32): if self.buffer.size() batch_size: return # 从经验回放中采样 states, actions, rewards, next_states, dones self.buffer.sample(batch_size) states torch.FloatTensor(states) actions torch.LongTensor(actions) rewards torch.FloatTensor(rewards) next_states torch.FloatTensor(next_states) dones torch.BoolTensor(dones) # 计算当前Q值 q_values self.q_net(states).gather(1, actions.unsqueeze(1)) # 计算目标Q值 next_q_values self.target_net(next_states).max(1)[0].detach() target_q_values rewards (self.gamma * next_q_values * ~dones) # 计算损失 loss F.mse_loss(q_values.squeeze(), target_q_values) # 梯度下降 self.optimizer.zero_grad() loss.backward() self.optimizer.step() # 定期更新目标网络 self.count 1 if self.count % 100 0: self.target_net.load_state_dict(self.q_net.state_dict())9. GNN图神经网络9.1 图神经网络基础GNN专门处理图结构数据通过消息传递机制聚合邻居信息。常见的GNN变体包括GCN、GraphSAGE、GAT等。图数据特点节点(Node)图中的实体边(Edge)节点之间的关系特征(Feature)节点或边的属性9.2 图卷积网络实现import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv from torch_geometric.datasets import Planetoid class GCN(torch.nn.Module): def __init__(self, num_features, hidden_channels, num_classes): super(GCN, self).__init__() self.conv1 GCNConv(num_features, hidden_channels) self.conv2 GCNConv(hidden_channels, num_classes) def forward(self, x, edge_index): x self.conv1(x, edge_index) x F.relu(x) x F.dropout(x, trainingself.training) x self.conv2(x, edge_index) return F.log_softmax(x, dim1) # 加载Cora数据集 dataset Planetoid(root/tmp/Cora, nameCora) data dataset[0] model GCN(num_featuresdataset.num_features, hidden_channels16, num_classesdataset.num_classes) optimizer torch.optim.Adam(model.parameters(), lr0.01, weight_decay5e-4) def train(): model.train() optimizer.zero_grad() out model(data.x, data.edge_index) loss F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss.item() def test(): model.eval() out model(data.x, data.edge_index) pred out.argmax(dim1) correct pred[data.test_mask] data.y[data.test_mask] acc int(correct.sum()) / int(data.test_mask.sum()) return acc # 训练循环 for epoch in range(200): loss train() if epoch % 50 0: acc test() print(fEpoch {epoch:03d}, Loss: {loss:.4f}, Acc: {acc:.4f})10. DBN深度信念网络10.1 DBN原理介绍深度信念网络由多个受限玻尔兹曼机(RBM)堆叠而成通过无监督预训练和有监督微调相结合的方式学习特征表示。RBM能量函数E(v, h) -∑ᵢaᵢvᵢ - ∑ⱼbⱼhⱼ - ∑ᵢ∑ⱼvᵢwᵢⱼhⱼ10.2 RBM实现import numpy as np class RBM: def __init__(self, n_visible, n_hidden): self.n_visible n_visible self.n_hidden n_hidden self.weights np.random.randn(n_visible, n_hidden) * 0.1 self.visible_bias np.zeros(n_visible) self.hidden_bias np.zeros(n_hidden) def sigmoid(self, x): return 1 / (1 np.exp(-x)) def sample_hidden(self, visible): hidden_activations np.dot(visible, self.weights) self.hidden_bias hidden_probs self.sigmoid(hidden_activations) hidden_states hidden_probs np.random.rand(*hidden_probs.shape) return hidden_probs, hidden_states def sample_visible(self, hidden): visible_activations np.dot(hidden, self.weights.T) self.visible_bias visible_probs self.sigmoid(visible_activations) visible_states visible_probs np.random.rand(*visible_probs.shape) return visible_probs, visible_states def contrastive_divergence(self, data, learning_rate0.1, k1): # 正相 positive_hidden_probs, positive_hidden_states self.sample_hidden(data) # 负相 hidden_states positive_hidden_states for _ in range(k): negative_visible_probs, negative_visible_states self.sample_visible(hidden_states) negative_hidden_probs, negative_hidden_states self.sample_hidden(negative_visible_states) hidden_states negative_hidden_states # 更新权重和偏置 positive_associations np.dot(data.T, positive_hidden_probs) negative_associations np.dot(negative_visible_states.T, negative_hidden_probs) self.weights learning_rate * (positive_associations - negative_associations) self.visible_bias learning_rate * np.mean(data - negative_visible_states, axis0) self.hidden_bias learning_rate * np.mean(positive_hidden_probs - negative_hidden_probs, axis0) # DBN实现示例 class DBN: def __init__(self, layers): self.rbms [] for i in range(len(layers) - 1): rbm RBM(layers[i], layers[i1]) self.rbms.append(rbm) def pretrain(self, data, epochs100, learning_rate0.1): current_data data for i, rbm in enumerate(self.rbms): print(f预训练第{i1}层RBM...) for epoch in range(epochs): rbm.contrastive_divergence(current_data, learning_rate) # 当前层的输出作为下一层的输入 _, current_data rbm.sample_hidden(current_data)11. 算法选择指南与实战建议11.1 根据任务类型选择算法图像处理任务图像分类CNN、Vision Transformer目标检测Faster R-CNN、YOLO基于CNN图像生成GAN、VAE图像分割U-Net、Mask R-CNN序列数据处理文本分类RNN、LSTM、Transformer机器翻译Seq2Seq with Attention、Transformer时间序列预测LSTM、GRU、TCN语音识别RNN、CNN、Transformer图结构数据社交网络分析GCN、GraphSAGE推荐系统GNN、NGCF分子性质预测GIN、MPNN决策控制问题游戏AIDQN、A3C、PPO机器人控制DDPG、SAC11.2 实战项目架构设计class DeepLearningPipeline: def __init__(self, model_type, task_type): self.model_type model_type self.task_type task_type self.model self._create_model() def _create_model(self): if self.model_type CNN: return self._create_cnn() elif self.model_type LSTM: return self._create_lstm() elif self.model_type Transformer: return self._create_transformer() # 其他模型类型... def _create_cnn(self): # CNN模型创建逻辑 pass def _create_lstm(self): # LSTM模型创建逻辑 pass def train(self, train_loader, val_loader, epochs100): # 统一的训练接口 best_acc 0 for epoch in range(epochs): # 训练阶段 self.model.train() for batch in train_loader: self._train_step(batch) # 验证阶段 acc self.validate(val_loader) if acc best_acc: best_acc acc self._save_checkpoint() def validate(self, val_loader): # 验证逻辑 pass11.3 模型部署与优化建议部署考虑因素推理速度模型压缩、量化、剪枝内存占用模型轻量化、动态加载硬件兼容CPU/GPU/边缘设备优化# 模型量化示例 model_fp32 SimpleCNN() model_fp32.eval() # 量化准备 model_fp32.qconfig torch.quantization.get_default_qconfig(fbgemm) model_prepared torch.quantization.prepare(model_fp32) # 校准使用少量数据 with torch.no_grad(): for data in calibration_data: model_prepared(data) # 转换量化模型 model_quantized torch.quantization.convert(model_prepared)12. 常见问题与解决方案12.1 训练过程中的典型问题过拟合问题现象训练集表现好测试集表现差解决方案增加数据、数据增强、Dropout、正则化、早停梯度问题梯度消失使用ReLU、BatchNorm、残差连接梯度爆炸梯度裁剪、权重初始化、BatchNorm训练不收敛检查学习率太大导致震荡太小导致收敛慢
