深度学习七大经典网络实战：从CNN到Transformer的工程化学习路径

很多同学在入门深度学习时，常常陷入一个误区：要么一头扎进复杂的数学公式推导，要么盲目追求最新最火的模型，结果学了很久还是无法上手实际项目。本文将从工程实战角度出发，系统梳理深度学习中七大经典网络模型的核心思想、适用场景和实战技巧，帮你建立清晰的学习路径，快速从理论过渡到项目落地。

1. 深度学习基础与学习路线规划

1.1 为什么深度学习不能盲目自学？

深度学习涉及数学基础、编程能力、工程实践等多个维度，自学容易陷入以下几个坑：

知识碎片化问题：网上教程质量参差不齐，知识点分散不成体系。比如学CNN时只看卷积原理，却不知道如何与全连接层配合；学Transformer时只关注自注意力机制，却不理解位置编码的实际作用。

理论与实践脱节：很多教程只讲理论不重实战，导致学完还是不会写代码。比如理解了反向传播的数学原理，但面对具体的梯度消失问题却无从下手。

版本兼容性陷阱：深度学习框架更新频繁，不同版本的API差异很大。比如TensorFlow 1.x和2.x的代码风格完全不同，PyTorch的版本升级也会带来接口变化。

1.2 科学的学习路线设计

建议按照以下四个阶段循序渐进：

第一阶段：基础夯实（1-2周）

• 掌握Python编程基础，特别是NumPy、Pandas数据处理
• 理解机器学习基本概念：监督学习、损失函数、优化算法
• 学习PyTorch或TensorFlow基础API

第二阶段：经典网络学习（3-4周）

• 按CNN → RNN → GNN → YOLO → Transformer顺序学习
• 每个网络都要完成从原理理解到代码实现的完整流程
• 重点掌握各网络的适用场景和局限性

第三阶段：项目实战（2-3周）

• 选择1-2个完整项目进行实战
• 学会数据预处理、模型训练、调参优化全流程
• 掌握模型评估和结果分析方法

第四阶段：进阶拓展（持续学习）

• 学习模型压缩、分布式训练等高级话题
• 跟进最新论文和技术发展
• 参与开源项目或竞赛提升实战能力

2. 卷积神经网络（CNN）深度解析

2.1 CNN的核心思想与网络结构

卷积神经网络的灵感来源于生物视觉皮层，通过局部连接和权值共享大幅减少参数数量。一个标准的CNN包含以下核心组件：

卷积层（Convolutional Layer）

• 作用：提取局部特征，如图像的边缘、纹理等
• 关键参数：卷积核大小、步长（stride）、填充（padding）
• 输出尺寸计算：(输入尺寸 - 核大小 + 2×填充) / 步长 + 1

池化层（Pooling Layer）

• 作用：降维、保持平移不变性、防止过拟合
• 常用类型：最大池化、平均池化
• 一般使用2×2池化窗口，步长为2

全连接层（Fully Connected Layer）

• 作用：将提取的特征进行组合，完成分类任务
• 通常放在网络最后，连接分类器

2.2 LeNet-5实战：手写数字识别

下面通过经典的LeNet-5网络实现MNIST手写数字识别：

import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms class LeNet5(nn.Module): def __init__(self): super(LeNet5, self).__init__() self.conv1 = nn.Conv2d(1, 6, 5, padding=2) # 输入通道1，输出通道6，卷积核5×5 self.pool1 = nn.AvgPool2d(2, 2) # 2×2平均池化 self.conv2 = nn.Conv2d(6, 16, 5) self.pool2 = nn.AvgPool2d(2, 2) self.fc1 = nn.Linear(16 * 5 * 5, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = torch.tanh(self.conv1(x)) x = self.pool1(x) x = torch.tanh(self.conv2(x)) x = self.pool2(x) x = x.view(-1, 16 * 5 * 5) # 展平 x = torch.tanh(self.fc1(x)) x = torch.tanh(self.fc2(x)) x = self.fc3(x) return x # 数据预处理 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 加载数据 train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST('./data', train=False, transform=transform) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False) # 训练配置 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = LeNet5().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练循环 def train(model, device, train_loader, optimizer, criterion, epoch): model.train() 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() if batch_idx % 100 == 0: print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}] Loss: {loss.item():.6f}') # 测试函数 def test(model, device, test_loader): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) 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 = 100. * correct / len(test_loader.dataset) print(f'Test set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)') return accuracy # 开始训练 for epoch in range(1, 11): train(model, device, train_loader, optimizer, criterion, epoch) test(model, device, test_loader)

2.3 CNN进阶：ResNet残差网络

随着网络层数加深，会出现梯度消失/爆炸问题。ResNet通过残差连接解决了深层网络训练难题：

import torch.nn as nn class BasicBlock(nn.Module): expansion = 1 def __init__(self, in_planes, planes, stride=1): super(BasicBlock, self).__init__() self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.shortcut = nn.Sequential() if stride != 1 or in_planes != self.expansion * planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(self.expansion * planes) ) def forward(self, x): out = nn.ReLU()(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) # 残差连接 out = nn.ReLU()(out) return out

3. 图神经网络（GNN）原理与应用

3.1 图神经网络的基本概念

图神经网络专门处理图结构数据，在社交网络、分子结构、推荐系统等领域有广泛应用。与CNN处理网格数据不同，GNN需要处理不定长的邻居节点信息。

图的基本组成：

• 节点（Node）：图中的实体
• 边（Edge）：节点之间的关系
• 特征（Feature）：节点或边的属性信息

消息传递机制：GNN的核心是通过邻居节点间的信息传递来更新节点表示。每个节点聚合邻居信息，然后结合自身信息更新状态。

3.2 GCN实战：节点分类任务

下面实现一个简单的图卷积网络（GCN）用于节点分类：

import torch import torch.nn as nn import torch.nn.functional as F from torch_geometric.nn import GCNConv from torch_geometric.datasets import Planetoid class GCN(nn.Module): def __init__(self, num_node_features, num_classes): super(GCN, self).__init__() self.conv1 = GCNConv(num_node_features, 16) self.conv2 = GCNConv(16, num_classes) def forward(self, data): x, edge_index = data.x, data.edge_index x = self.conv1(x, edge_index) x = F.relu(x) x = F.dropout(x, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) # 加载Cora数据集（论文引用网络） dataset = Planetoid(root='/tmp/Cora', name='Cora') data = dataset[0] print(f'数据集: {dataset}') print(f'图节点数: {data.num_nodes}') print(f'边数: {data.num_edges}') print(f'节点特征维度: {data.num_node_features}') print(f'类别数: {dataset.num_classes}') # 创建模型和优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = GCN(dataset.num_node_features, dataset.num_classes).to(device) data = data.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # 训练函数 def train(): model.train() optimizer.zero_grad() out = model(data) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss # 测试函数 def test(): model.eval() out = model(data) pred = out.argmax(dim=1) 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(1, 201): loss = train() if epoch % 50 == 0: acc = test() print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Test Acc: {acc:.4f}')

3.3 GNN应用场景与最佳实践

应用场景选择：

• 社交网络分析：用户推荐、社区发现
• 化学分子分析：药物发现、材料设计
• 知识图谱：智能问答、推理系统
• 交通网络：路径规划、流量预测

实践注意事项：

1. 图数据预处理很重要，需要合理构建邻接矩阵
2. 注意过拟合问题，GNN容易在训练集上表现很好但泛化能力差
3. 大规模图需要采用采样策略，如GraphSAGE的邻居采样

4. YOLO目标检测实战指南

4.1 YOLO算法核心思想

YOLO（You Only Look Once）将目标检测视为回归问题，直接在单个网络中预测边界框和类别概率。相比传统的两阶段检测器，YOLO速度更快，适合实时应用。

YOLO v8核心改进：

• 锚框免费（Anchor-free）设计：简化了训练流程
• 更高效的特征金字塔：更好的多尺度检测
• 更丰富的预训练模型：从n到x不同尺度的模型

4.2 YOLOv8环境配置与基础使用

# 安装Ultralytics包 # pip install ultralytics from ultralytics import YOLO import cv2 import matplotlib.pyplot as plt # 加载预训练模型 model = YOLO('yolov8n.pt') # 使用nano版本，体积小速度快 # 进行目标检测 results = model('https://ultralytics.com/images/bus.jpg') # 显示结果 for r in results: im_array = r.plot() # 绘制检测结果 im = cv2.cvtColor(im_array, cv2.COLOR_BGR2RGB) plt.imshow(im) plt.axis('off') plt.show() # 打印检测到的物体信息 for result in results: boxes = result.boxes for box in boxes: cls_id = int(box.cls[0]) conf = box.conf[0] xyxy = box.xyxy[0] print(f"类别: {model.names[cls_id]}, 置信度: {conf:.2f}, 坐标: {xyxy}")

4.3 自定义数据集训练YOLOv8

准备自定义数据集的完整流程：

1. 数据准备格式

dataset/ ├── images/ │ ├── train/ │ └── val/ └── labels/ ├── train/ └── val/

2. 创建数据集配置文件

# data.yaml path: /path/to/dataset train: images/train val: images/val nc: 3 # 类别数量 names: ['cat', 'dog', 'person'] # 类别名称

3. 训练自定义模型

from ultralytics import YOLO # 加载预训练模型 model = YOLO('yolov8n.pt') # 开始训练 results = model.train( data='data.yaml', epochs=100, imgsz=640, batch=16, device=0, # 使用GPU workers=4, patience=10, # 早停耐心值 save=True, verbose=True ) # 验证模型性能 metrics = model.val() print(f"mAP50-95: {metrics.box.map:.4f}") print(f"mAP50: {metrics.box.map50:.4f}")

4.4 YOLO常见问题与解决方案

问题1：检测框位置不准确

• 原因：锚框尺寸不匹配或特征图分辨率不够
• 解决：调整输入图像尺寸，使用更适合的预训练锚框

问题2：小目标检测效果差

• 原因：小目标在深层特征图中信息丢失
• 解决：使用更高分辨率的输入，增加小目标检测层

问题3：训练时损失震荡

• 原因：学习率过大或批次大小不合适
• 解决：减小学习率，增加批次大小，使用学习率预热

5. Transformer架构深入解析

5.1 自注意力机制原理

Transformer的核心是自注意力机制，它允许模型在处理每个位置时关注输入序列的所有位置。

自注意力计算公式：

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

其中：

• Q（Query）：查询向量
• K（Key）：键向量
• V（Value）：值向量
• d_k：键向量的维度

import torch import torch.nn as nn import math 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)

5.2 编码器-解码器架构实现

完整的Transformer包含编码器和解码器两部分：

class Transformer(nn.Module): def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout): super(Transformer, self).__init__() self.encoder = Encoder(src_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout) self.decoder = Decoder(tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout) self.final_linear = nn.Linear(d_model, tgt_vocab_size) def forward(self, src, tgt, src_mask, tgt_mask): encoder_output = self.encoder(src, src_mask) decoder_output = self.decoder(tgt, encoder_output, src_mask, tgt_mask) output = self.final_linear(decoder_output) return output # 位置编码 class PositionalEncoding(nn.Module): def __init__(self, d_model, max_seq_length): super(PositionalEncoding, self).__init__() pe = torch.zeros(max_seq_length, d_model) position = torch.arange(0, max_seq_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) self.register_buffer('pe', pe) def forward(self, x): return x + self.pe[:, :x.size(1)]

5.3 Transformer在CV领域的应用：Vision Transformer

Vision Transformer将图像分割成patch序列，然后使用标准Transformer进行处理：

import torch import torch.nn as nn class PatchEmbedding(nn.Module): def __init__(self, image_size=224, patch_size=16, in_channels=3, embed_dim=768): super().__init__() self.image_size = image_size self.patch_size = patch_size self.num_patches = (image_size // patch_size) ** 2 self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size) def forward(self, x): x = self.proj(x) # [B, C, H, W] -> [B, E, H/P, W/P] x = x.flatten(2) # [B, E, H/P, W/P] -> [B, E, N] x = x.transpose(1, 2) # [B, E, N] -> [B, N, E] return x class VisionTransformer(nn.Module): def __init__(self, image_size=224, patch_size=16, in_channels=3, num_classes=1000, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4.0): super().__init__() self.patch_embed = PatchEmbedding(image_size, patch_size, in_channels, embed_dim) self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) self.pos_embed = nn.Parameter(torch.zeros(1, self.patch_embed.num_patches + 1, embed_dim)) self.blocks = nn.ModuleList([ TransformerBlock(embed_dim, num_heads, mlp_ratio) for _ in range(depth) ]) self.norm = nn.LayerNorm(embed_dim) self.head = nn.Linear(embed_dim, num_classes) def forward(self, x): B = x.shape[0] x = self.patch_embed(x) cls_tokens = self.cls_token.expand(B, -1, -1) x = torch.cat((cls_tokens, x), dim=1) x = x + self.pos_embed for block in self.blocks: x = block(x) x = self.norm(x) cls_token_final = x[:, 0] return self.head(cls_token_final)

6. 七大经典网络对比与选型指南

6.1 技术特性对比分析

6.2 实际项目选型建议

计算机视觉项目：

• 图像分类：优先选择ResNet、EfficientNet
• 目标检测：YOLO系列（实时需求）、Faster R-CNN（精度优先）
• 语义分割：U-Net、DeepLab系列
• 图像生成：GAN、Diffusion Models

自然语言处理项目：

• 文本分类：BERT、RoBERTa
• 机器翻译：Transformer、T5
• 文本生成：GPT系列、T5
• 序列标注：BiLSTM-CRF、BERT

图数据项目：

• 节点分类：GCN、GraphSAGE
• 链接预测：GAT、SEAL
• 图分类：DiffPool、GIN

6.3 混合架构设计策略

在实际项目中，经常需要组合多种网络架构：

class MultiModalNetwork(nn.Module): """多模态网络示例：结合CNN和Transformer""" def __init__(self, num_classes): super().__init__() # 图像特征提取 self.cnn_backbone = torchvision.models.resnet50(pretrained=True) self.cnn_backbone.fc = nn.Identity() # 移除最后的分类层 # 文本特征提取 self.text_encoder = TransformerEncoder(vocab_size=30000, d_model=512) # 多模态融合 self.fusion_layer = nn.TransformerEncoder( nn.TransformerEncoderLayer(d_model=1024, nhead=8), num_layers=3 ) self.classifier = nn.Linear(1024, num_classes) def forward(self, images, texts): # 提取图像特征 img_features = self.cnn_backbone(images) # [B, 2048] # 提取文本特征 text_features = self.text_encoder(texts) # [B, 512] # 特征拼接和融合 combined = torch.cat([img_features, text_features], dim=1) # [B, 2560] combined = combined.unsqueeze(1) # [B, 1, 2560] # 通过Transformer融合 fused = self.fusion_layer(combined) # [B, 1, 2560] fused = fused.squeeze(1) # [B, 2560] # 分类 output = self.classifier(fused) return output

7. 深度学习项目实战全流程

7.1 项目开发标准化流程

阶段一：需求分析与数据准备

1. 明确业务目标和评估指标
2. 数据收集与清洗
3. 数据标注与质量检查
4. 数据集划分（训练/验证/测试）

阶段二：模型选择与实验

1. 基线模型建立
2. 模型架构实验
3. 超参数调优
4. 交叉验证评估

阶段三：模型优化与部署

1. 模型压缩与加速
2. 部署环境适配
3. 监控与维护方案
4. 持续改进机制

7.2 完整项目示例：智能垃圾分类系统

import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader from torchvision import transforms, models from PIL import Image import os class WasteClassificationDataset(Dataset): def __init__(self, data_dir, transform=None): self.data_dir = data_dir self.transform = transform self.classes = ['plastic', 'paper', 'metal', 'glass', 'other'] self.image_paths = [] self.labels = [] for class_idx, class_name in enumerate(self.classes): class_dir = os.path.join(data_dir, class_name) for img_name in os.listdir(class_dir): self.image_paths.append(os.path.join(class_dir, img_name)) self.labels.append(class_idx) def __len__(self): return len(self.image_paths) def __getitem__(self, idx): image = Image.open(self.image_paths[idx]).convert('RGB') label = self.labels[idx] if self.transform: image = self.transform(image) return image, label # 数据增强和预处理 train_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.RandomRotation(10), transforms.ColorJitter(brightness=0.2, contrast=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) val_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # 创建模型 class WasteClassifier(nn.Module): def __init__(self, num_classes=5): super().__init__() self.backbone = models.efficientnet_b0(pretrained=True) self.backbone.classifier[1] = nn.Linear(self.backbone.classifier[1].in_features, num_classes) def forward(self, x): return self.backbone(x) # 训练配置 def train_model(): # 数据集 train_dataset = WasteClassificationDataset('data/train', train_transform) val_dataset = WasteClassificationDataset('data/val', val_transform) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False) # 模型和优化器 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = WasteClassifier().to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) # 训练循环 best_acc = 0 for epoch in range(50): model.train() running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() # 验证 model.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in val_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() acc = 100 * correct / total print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}, Acc: {acc:.2f}%') if acc > best_acc: best_acc = acc torch.save(model.state_dict(), 'best_model.pth') scheduler.step() print(f'Best validation accuracy: {best_acc:.2f}%')

7.3 模型部署与性能优化

模型压缩技术：

import torch import torch.nn as nn import torch.quantization # 模型量化 def quantize_model(model): model.eval() model.qconfig = torch.quantization.get_default_qconfig('fbgemm') model_prepared = torch.quantization.prepare(model, inplace=False) # 这里需要校准数据... model_quantized = torch.quantization.convert(model_prepared) return model_quantized # 模型剪枝 def prune_model(model, pruning_rate=0.3): parameters_to_prune = [] for name, module in model.named_modules(): if isinstance(module, nn.Conv2d) or isinstance(module, nn.Linear): parameters_to_prune.append((module, 'weight')) torch.nn.utils.prune.global_unstructured( parameters_to_prune, pruning_method=torch.nn.utils.prune.L1Unstructured, amount=pruning_rate, ) return model

8. 常见问题深度排查手册

8.1 训练过程中的典型问题

问题：损失函数不下降

• 检查学习率是否合适（太大震荡，太小下降慢）
• 验证数据预处理是否正确
• 检查模型初始化是否合理
• 确认损失函数和任务匹配

问题：过拟合严重

• 增加数据增强强度
• 添加正则化（Dropout、L2正则）
• 使用早停策略
• 简化模型结构

问题：梯度爆炸/消失

• 使用梯度裁剪
• 调整激活函数（ReLU、LeakyReLU）
• 使用Batch Normalization
• 检查网络深度是否合理

8.2 部署实践中的注意事项

环境一致性保证：

# 版本锁定文件示例：requirements.txt torch==1.13.1 torchvision==0.14.1 numpy==1.21.6 opencv-python==4.7.0.72 pillow==9.4.0

模型服务化示例：

from flask import Flask, request, jsonify import torch from PIL import Image import io app = Flask(__name__) model = None def load_model(): global model model = WasteClassifier() model.load_state_dict(torch.load('best_model.pth', map_location='cpu')) model.eval() @app.route('/predict', methods=['POST']) def predict(): if 'image' not in request.files: return jsonify({'error': 'No image provided'}), 400 image_file = request.files['image'] image = Image.open(io.BytesIO(image_file.read())).convert('RGB') # 预处理 transform = val_transform # 使用验证时的变换 image_tensor = transform(image).unsqueeze(0) # 预测 with torch.no_grad(): output = model(image_tensor) probabilities = torch.softmax(output, dim=1) predicted_class = torch.argmax(probabilities, dim=1).item() confidence = probabilities[0][predicted_class].item() class_names = ['plastic', 'paper', 'metal', 'glass', 'other'] return jsonify({ 'class': class_names[predicted_class], 'confidence': confidence }) if __name__ == '__main__': load_model() app.run(host='0.0.0.0', port=5000)

通过系统学习这七大经典网络，建立完整的深度学习知识体系，再结合项目实战经验，就能在实际工作中游刃有余。建议从简单的CNN项目开始，逐步扩展到更复杂的多模态任务，在实践中不断深化理解。