计算机视觉入门：图像识别、目标检测与图像分割核心原理与实战

很多同学在入门计算机视觉时，常常感到迷茫：面对目标检测、图像分割、图像识别这些术语，不知道它们之间有什么区别，更不知道从何学起、如何实践。网上资料要么过于理论，要么代码片段零散，难以串联成一个完整的知识体系。

本文将为你系统梳理计算机视觉的三大核心方向——图像识别、目标检测、图像分割。我们将从深度学习的基础概念讲起，逐步深入到每个方向的核心原理、主流算法和实战代码。无论你是刚接触CV的新手，还是希望系统梳理知识体系的开发者，都能从本文中获得清晰的路线图和可直接运行的代码示例。学完后，你将能够理解不同任务的区别，并动手实现基础的视觉模型。

1. 计算机视觉与深度学习基础

在深入具体任务之前，我们需要建立对计算机视觉（Computer Vision, CV）和深度学习（Deep Learning）的基本认知。这是理解后续所有内容的地基。

1.1 什么是计算机视觉？

简单来说，计算机视觉是让计算机“看懂”图像和视频内容的技术。它模仿人类视觉系统，从数字图像或视频中提取、分析和理解信息。其核心目标是实现从像素到语义的跨越。

计算机视觉的应用无处不在：

• 安防监控：人脸识别、异常行为检测。
• 自动驾驶：车辆、行人、交通标志的检测与识别。
• 医疗影像：病灶分割、疾病辅助诊断。
• 工业质检：产品缺陷检测、零件定位。
• 手机应用：美颜滤镜、图片分类、AR特效。

1.2 深度学习如何赋能计算机视觉？

传统的计算机视觉方法严重依赖手工设计的特征（如SIFT, HOG），这些特征在复杂、多变的场景下泛化能力有限。深度学习的革命性在于，它使用多层神经网络（尤其是卷积神经网络CNN）自动从海量数据中学习层次化的特征表示。

• 低层特征：边缘、角点、纹理。
• 中层特征：部件、形状。
• 高层特征：物体、场景。

这种端到端的学习方式，使得模型性能在多项视觉任务上取得了突破性进展。可以说，现代计算机视觉的核心引擎就是深度学习。

1.3 三大核心任务：识别、检测与分割

这是本文的重点，也是初学者最容易混淆的地方。我们可以用一个简单的例子来区分：

假设有一张街景图，图中有一辆汽车、一个行人和一只狗。

• 图像识别（Image Classification）：回答“图里有什么？” 例如，输出“街道场景”。它关注的是整张图像的全局类别。
• 目标检测（Object Detection）：回答“有什么，分别在哪？” 例如，输出“汽车（在坐标[x1,y1,x2,y2]）、行人（在坐标…）、狗（在坐标…）”。它需要找出图中所有感兴趣物体，并用矩形框（Bounding Box）标出位置和类别。
• 图像分割（Image Segmentation）：回答“每个像素属于什么？” 它将图像中的每个像素都分配一个类别标签，生成一张像素级的分类图。这又分为两种：
  • 语义分割（Semantic Segmentation）：只区分类别，不区分个体。例如，图中所有“行人”的像素都被标记为同一类。
  • 实例分割（Instance Segmentation）：在语义分割的基础上，进一步区分同一类别的不同个体。例如，两个行人的像素会被标记为“行人1”和“行人2”。

理解了这些基本概念，我们就可以开始搭建环境，准备实战了。

2. 环境准备与工具选择

工欲善其事，必先利其器。一个稳定、高效的开发环境是成功的第一步。考虑到通用性和学习成本，我们选择Python作为编程语言，PyTorch作为深度学习框架。

2.1 基础环境配置

1. 操作系统：推荐使用Ubuntu 20.04/22.04 LTS或Windows 10/11。本文示例在 Ubuntu 22.04 下完成，Windows 用户可参考对应步骤。
2. Python：建议使用Python 3.8 或 3.9。版本过高或过低可能导致一些库的兼容性问题。
3. 包管理工具：使用pip或conda。conda在管理环境和解决依赖冲突方面更有优势。

2.2 核心库安装

我们将使用conda创建一个独立的虚拟环境，避免污染系统环境。

# 1. 创建并激活名为 `cv_tutorial` 的虚拟环境 conda create -n cv_tutorial python=3.9 -y conda activate cv_tutorial # 2. 安装 PyTorch (以CPU版本为例，如需GPU请访问PyTorch官网选择对应命令) # 访问 https://pytorch.org/get-started/locally/ 获取最新安装命令 # 例如，对于稳定版的CPU版本： pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu # 3. 安装计算机视觉常用库 pip install opencv-python # OpenCV， 图像处理核心库 pip install pillow # PIL的友好分支，图像处理 pip install matplotlib # 绘图库 pip install numpy # 数值计算 pip install scikit-learn # 机器学习工具 pip install jupyter notebook # 交互式笔记本（可选，但强烈推荐）

验证安装：打开 Python 解释器，运行以下代码检查关键库是否就绪。

import torch import torchvision import cv2 import numpy as np import matplotlib.pyplot as plt print(f"PyTorch 版本: {torch.__version__}") print(f"Torchvision 版本: {torchvision.__version__}") print(f"OpenCV 版本: {cv2.__version__}") print(f"CUDA 是否可用: {torch.cuda.is_available()}") # 如果安装了GPU版本，这里会显示True

如果以上命令都能成功执行并输出版本号，恭喜你，基础环境已经搭建完成！

2.3 数据集与项目结构

为了后续实战，我们先创建一个清晰的项目目录，并准备一个微型数据集。

# 项目目录结构建议 cv_from_zero_to_hero/ ├── data/ # 存放数据集 │ ├── classification/ # 图像识别数据 │ ├── detection/ # 目标检测数据 │ └── segmentation/ # 图像分割数据 ├── notebooks/ # Jupyter Notebook 文件 ├── src/ # 源代码 │ ├── classification.py │ ├── detection.py │ └── segmentation.py ├── models/ # 保存训练好的模型 ├── outputs/ # 保存输出结果（预测图、日志等） ├── requirements.txt # 项目依赖 └── README.md

对于学习，我们不需要海量数据。可以使用torchvision.datasets中内置的小型数据集（如 CIFAR-10, MNIST），或者从网上下载一些公开的样例图片。在接下来的章节中，我们会具体说明如何加载和使用数据。

3. 图像识别实战：从零训练一个分类器

图像识别是计算机视觉的基石。我们将使用经典的CIFAR-10数据集，它包含10个类别的6万张32x32彩色小图。我们的任务是训练一个模型，让它能正确识别出图片是“飞机”、“汽车”、“鸟”等中的哪一类。

3.1 数据加载与预处理

PyTorch 提供了非常方便的数据加载工具DataLoader。

# src/classification.py import torch import torchvision import torchvision.transforms as transforms import matplotlib.pyplot as plt import numpy as np # 1. 定义数据预处理管道 # 将PIL图像转换为Tensor，并做归一化（均值，标准差根据数据集计算得出） transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 归一化到[-1, 1] ]) # 2. 下载并加载训练集和测试集 batch_size = 4 trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2) # CIFAR-10的类别 classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # 3. 可视化一些训练图片 def imshow(img): img = img / 2 + 0.5 # 反归一化 npimg = img.numpy() plt.imshow(np.transpose(npimg, (1, 2, 0))) # 将Tensor的(C, H, W)转换为(H, W, C) plt.show() # 获取一个批次的随机训练图像 dataiter = iter(trainloader) images, labels = next(dataiter) # 显示图像 imshow(torchvision.utils.make_grid(images)) # 打印标签 print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))

运行这段代码，你会看到4张随机的小图片及其标签。数据预处理是深度学习的关键一步，Normalize能加速模型收敛，DataLoader的shuffle能打乱数据顺序，防止模型学习到无关的顺序特征。

3.2 构建一个简单的卷积神经网络（CNN）

我们将构建一个简化版的CNN，它包含卷积层、池化层和全连接层。

# src/classification.py (续) import torch.nn as nn import torch.nn.functional as F class SimpleCNN(nn.Module): def __init__(self): super().__init__() # 卷积层1：输入3通道(RGB)，输出6个特征图，卷积核5x5 self.conv1 = nn.Conv2d(3, 6, 5) # 池化层：窗口2x2，步长2 self.pool = nn.MaxPool2d(2, 2) # 卷积层2：输入6通道，输出16通道 self.conv2 = nn.Conv2d(6, 16, 5) # 全连接层1 self.fc1 = nn.Linear(16 * 5 * 5, 120) # 经过两次池化，图像尺寸从32->16->5 # 全连接层2 self.fc2 = nn.Linear(120, 84) # 全连接层3 (输出层)：10个类别 self.fc3 = nn.Linear(84, 10) def forward(self, x): # 卷积 -> 激活(ReLU) -> 池化 x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) # 展平特征图为一维向量 x = torch.flatten(x, 1) # 从第1维开始展平（忽略batch维度） # 全连接层 x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x net = SimpleCNN() print(net)

关键点解释：

• nn.Conv2d: 卷积层，是CNN的核心，用于提取局部特征。
• nn.MaxPool2d: 最大池化层，用于降维和保留主要特征，增强平移不变性。
• nn.Linear: 全连接层，用于最终的分类决策。
• F.relu: 激活函数，引入非线性，使网络能够学习复杂模式。
• torch.flatten: 将多维特征图转换为一维向量，以便输入全连接层。

3.3 训练与评估模型

接下来，我们定义损失函数、优化器，并开始训练循环。

# src/classification.py (续) import torch.optim as optim # 1. 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() # 交叉熵损失，适用于多分类 optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # 随机梯度下降 # 2. 训练循环 for epoch in range(5): # 在完整数据集上循环多次 running_loss = 0.0 for i, data in enumerate(trainloader, 0): # 获取输入数据 inputs, labels = data # 梯度清零 optimizer.zero_grad() # 前向传播 + 反向传播 + 优化 outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # 打印统计信息 running_loss += loss.item() if i % 2000 == 1999: # 每2000个小批次打印一次 print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}') running_loss = 0.0 print('Finished Training') # 3. 在测试集上评估模型 correct = 0 total = 0 # 在评估时不需要计算梯度 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) # 取概率最高的类别作为预测结果 _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')

训练完成后，你会在测试集上得到一个准确率（大约在60%左右）。这个简单的CNN模型性能有限，但完整展示了图像识别任务的整个流程：数据加载 -> 网络定义 -> 训练 -> 评估。

3.4 使用预训练模型（迁移学习）

在实际项目中，我们很少从零开始训练。更常见的做法是使用在大型数据集（如ImageNet）上预训练好的模型，然后针对自己的任务进行微调（Fine-tuning）。这能极大缩短训练时间并提升性能。

# src/classification_finetune.py import torchvision.models as models import torch.nn as nn # 1. 加载预训练的ResNet18模型 # `pretrained=True` 会自动下载预训练权重 model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1) # 2. 冻结所有卷积层的参数（不更新） for param in model.parameters(): param.requires_grad = False # 3. 替换最后的全连接层，以适应我们的10分类任务 num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 10) # CIFAR-10有10类 # 现在，只有 `model.fc` 层的参数需要训练。 # 4. 定义优化器，只优化最后一层参数 optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9) # ... (后续训练和评估代码与之前类似，但数据可能需要调整尺寸以匹配ResNet的输入)

通过迁移学习，即使在小数据集上，也能快速获得一个高性能的分类器。

4. 目标检测实战：用YOLO快速定位物体

目标检测不仅要识别物体，还要找到它的位置。YOLO（You Only Look Once）系列是当前最流行、速度最快的检测算法之一。我们将使用ultralytics提供的 YOLOv8 来快速体验目标检测。

4.1 YOLO核心思想与安装

YOLO将目标检测视为一个回归问题。它将输入图像划分为 S×S 的网格，每个网格负责预测中心落在该网格内的物体。每个预测包含边界框坐标、置信度和类别概率。

安装ultralytics库非常简单：

pip install ultralytics

4.2 使用预训练YOLO模型进行推理

ultralytics库封装得非常好，几行代码就能完成检测。

# src/detection_yolo.py from ultralytics import YOLO import cv2 # 1. 加载一个预训练的YOLOv8模型（例如YOLOv8n，nano版本，速度最快） model = YOLO('yolov8n.pt') # 首次运行会自动下载模型 # 2. 准备一张测试图片（这里使用库自带的示例图片，你也可以替换为自己的图片路径） # 你可以从网上下载一张包含人、车等物体的图片，保存为 `test_image.jpg` img_path = 'test_image.jpg' # 请确保文件存在 # 或者使用示例图片（如果存在） # import urllib.request # urllib.request.urlretrieve('https://ultralytics.com/images/bus.jpg', 'bus.jpg') # img_path = 'bus.jpg' # 3. 进行推理 results = model(img_path) # 4. 可视化结果 # 方法1：使用ultralytics内置的plot功能 for r in results: im_array = r.plot() # 绘制了边界框和标签的BGR numpy数组 cv2.imshow('YOLOv8 Detection', im_array) cv2.waitKey(0) cv2.destroyAllWindows() # 方法2：获取详细的检测结果并自己处理 for r in results: boxes = r.boxes # 边界框对象 for box in boxes: # 获取坐标 (xyxy格式) x1, y1, x2, y2 = box.xyxy[0].tolist() # 获取置信度 conf = box.conf[0].item() # 获取类别ID和名称 cls_id = int(box.cls[0].item()) cls_name = model.names[cls_id] print(f"Detected {cls_name} with confidence {conf:.2f} at [{x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}]")

运行这段代码，你会看到图片上画出了检测框，并打印出每个检测到的物体类别、置信度和位置。YOLOv8 预训练模型可以检测 COCO 数据集中的80个常见类别，如人、车、狗、椅子等。

4.3 在自己的数据上训练YOLO

如果你想检测自定义的物体（例如，某种特定的工业零件、珍稀鸟类），就需要用自己的数据训练模型。这需要准备特定格式的数据集（通常是YOLO格式或COCO格式）。

YOLO格式数据集结构：

custom_dataset/ ├── images/ │ ├── train/ │ │ ├── image1.jpg │ │ └── ... │ └── val/ │ ├── image100.jpg │ └── ... └── labels/ ├── train/ │ ├── image1.txt │ └── ... └── val/ ├── image100.txt └── ...

每个.txt标签文件对应一张图片，每行格式为：<class_id> <x_center> <y_center> <width> <height>，坐标是归一化后的（0-1之间）。

准备好数据后，创建一个data.yaml配置文件：

# data.yaml path: /path/to/custom_dataset # 数据集根目录 train: images/train # 训练集图片路径（相对于path） val: images/val # 验证集图片路径 # 类别数量和名称 nc: 3 # 你的类别数，例如3 names: ['class0', 'class1', 'class2'] # 类别名称列表

然后，使用几行代码开始训练：

# src/train_yolo.py from ultralytics import YOLO # 1. 加载一个基础模型（如YOLOv8s） model = YOLO('yolov8s.pt') # 2. 开始训练 results = model.train( data='data.yaml', # 数据集配置文件路径 epochs=100, # 训练轮数 imgsz=640, # 输入图像尺寸 batch=16, # 批次大小（根据GPU内存调整） name='my_custom_model' # 训练结果保存的名称 )

训练完成后，模型会保存在runs/detect/my_custom_model/weights/best.pt。你可以像使用预训练模型一样使用它进行推理。

5. 图像分割实战：用U-Net进行语义分割

图像分割为每个像素分配标签。U-Net 是一种经典的编码器-解码器结构网络，最初为生物医学图像分割设计，现广泛应用于各种分割任务。

5.1 U-Net网络结构理解

U-Net 形似字母“U”，因此得名。

• 编码器（下采样路径）：通过卷积和池化逐步提取高层特征，捕获图像的上下文信息（“是什么”）。
• 解码器（上采样路径）：通过转置卷积和跳跃连接（Skip Connections），逐步恢复空间细节，实现精确定位（“在哪里”）。
• 跳跃连接：将编码器对应层的特征图与解码器特征图拼接，帮助解码器恢复在池化过程中丢失的细节信息。

5.2 实现一个简化的U-Net

我们将使用PyTorch实现一个简化版的U-Net来处理二分类分割任务（例如，前景/背景）。

# src/segmentation_unet.py import torch import torch.nn as nn import torch.nn.functional as F class DoubleConv(nn.Module): """(卷积 => [BN] => ReLU) * 2""" def __init__(self, in_channels, out_channels): super().__init__() self.double_conv = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True) ) def forward(self, x): return self.double_conv(x) class Down(nn.Module): """下采样：MaxPool + DoubleConv""" def __init__(self, in_channels, out_channels): super().__init__() self.maxpool_conv = nn.Sequential( nn.MaxPool2d(2), DoubleConv(in_channels, out_channels) ) def forward(self, x): return self.maxpool_conv(x) class Up(nn.Module): """上采样：转置卷积 + 跳跃连接 + DoubleConv""" def __init__(self, in_channels, out_channels): super().__init__() self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2) self.conv = DoubleConv(in_channels, out_channels) # 注意输入通道是拼接后的 def forward(self, x1, x2): # x1: 来自解码器的特征图 # x2: 来自编码器的对应特征图（跳跃连接） x1 = self.up(x1) # 处理尺寸可能不匹配的情况（由于池化舍入） diffY = x2.size()[2] - x1.size()[2] diffX = x2.size()[3] - x1.size()[3] x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2, diffY // 2, diffY - diffY // 2]) # 拼接特征图 x = torch.cat([x2, x1], dim=1) # 沿通道维度拼接 return self.conv(x) class OutConv(nn.Module): """最后的1x1卷积，将通道数映射到类别数""" def __init__(self, in_channels, out_channels): super(OutConv, self).__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1) def forward(self, x): return self.conv(x) class UNet(nn.Module): def __init__(self, n_channels, n_classes): super(UNet, self).__init__() self.n_channels = n_channels self.n_classes = n_classes self.inc = DoubleConv(n_channels, 64) self.down1 = Down(64, 128) self.down2 = Down(128, 256) self.down3 = Down(256, 512) self.down4 = Down(512, 1024) self.up1 = Up(1024, 512) self.up2 = Up(512, 256) self.up3 = Up(256, 128) self.up4 = Up(128, 64) self.outc = OutConv(64, n_classes) def forward(self, x): x1 = self.inc(x) x2 = self.down1(x1) x3 = self.down2(x2) x4 = self.down3(x3) x5 = self.down4(x4) x = self.up1(x5, x4) x = self.up2(x, x3) x = self.up3(x, x2) x = self.up4(x, x1) logits = self.outc(x) return logits # 实例化一个U-Net模型（输入3通道RGB图，输出2类） model = UNet(n_channels=3, n_classes=2) print(model)

5.3 训练与评估分割模型

分割任务的训练与分类类似，但损失函数通常使用Dice Loss或交叉熵损失。数据加载也需要同时加载原图和对应的掩码（Mask）图。

# src/segmentation_train.py (伪代码，展示流程) import torch.optim as optim from torch.utils.data import DataLoader, Dataset from PIL import Image import torchvision.transforms as T # 1. 自定义数据集类（假设图片和掩码图分别放在`images`和`masks`文件夹） class SegmentationDataset(Dataset): def __init__(self, img_dir, mask_dir, transform=None): self.img_dir = img_dir self.mask_dir = mask_dir self.transform = transform self.images = os.listdir(img_dir) def __len__(self): return len(self.images) def __getitem__(self, idx): img_path = os.path.join(self.img_dir, self.images[idx]) mask_path = os.path.join(self.mask_dir, self.images[idx].replace('.jpg', '_mask.png')) image = Image.open(img_path).convert("RGB") mask = Image.open(mask_path).convert("L") # 灰度图，单通道 if self.transform: image = self.transform(image) mask = self.transform(mask) # 注意：对mask通常只需要ToTensor # 将mask的像素值转换为类别ID（例如，0为背景，1为前景） mask = (mask > 0).long().squeeze() # 假设掩码图中前景像素值>0 return image, mask # 2. 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() # 对于多分类分割，使用交叉熵 # criterion = DiceLoss() # 也可以使用Dice Loss optimizer = optim.Adam(model.parameters(), lr=1e-4) # 3. 训练循环（与分类任务类似，但输入是图像，标签是掩码图） for epoch in range(num_epochs): model.train() for images, masks in train_loader: optimizer.zero_grad() outputs = model(images) # outputs shape: [B, C, H, W] loss = criterion(outputs, masks) # masks shape: [B, H, W] loss.backward() optimizer.step() # ... 在验证集上评估 ... # 4. 推理与可视化 model.eval() with torch.no_grad(): output = model(test_image.unsqueeze(0)) # 增加batch维度 prediction = torch.argmax(output, dim=1).squeeze().cpu().numpy() # 取概率最高的类别 # prediction 就是每个像素的预测类别ID，可以将其可视化为彩色分割图

对于更复杂的分割任务（如医学图像、街景分割），可以使用预训练的编码器（如ResNet）作为U-Net的骨干网络，或者直接使用segmentation_models_pytorch这样的高级库。

6. 常见问题与排查思路

在实际操作中，你可能会遇到各种问题。这里列出一些高频问题及其解决方案。

7. 最佳实践与进阶路线

掌握了基础实战后，要走向工程化和深入，需要关注以下最佳实践和学习方向。

7.1 工程化最佳实践

1. 版本控制：使用 Git 管理代码、配置和实验记录。为每次重要的训练提交一个版本。
2. 实验管理：使用工具（如Weights & Biases,TensorBoard,MLflow）记录超参数、损失曲线、评估指标和预测结果。这能帮助你高效地复现实验和比较不同模型。
3. 数据管道优化：使用DataLoader的num_workers参数进行多进程数据加载，使用pin_memory=True加速GPU数据传输。确保数据增强在CPU上完成。
4. 混合精度训练：对于支持Tensor Core的GPU（如NVIDIA Volta及以上），使用torch.cuda.amp进行自动混合精度训练，可以显著减少内存占用并加快训练速度。
5. 模型保存与加载：不仅要保存模型权重（state_dict），还要保存优化器状态、当前epoch等信息，以便从中断处恢复训练。

   # 保存检查点 torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'loss': loss, }, 'checkpoint.pth') # 加载检查点 checkpoint = torch.load('checkpoint.pth') model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch']

6. 模型部署：训练好的模型需要部署到生产环境。研究ONNX、TensorRT（NVIDIA GPU）、LibTorch（C++）或TorchScript进行模型转换和优化，以满足延迟和吞吐量的要求。

7.2 深入学习路线建议

完成本文的三大方向入门后，你可以根据自己的兴趣选择深入：

• 图像识别方向：

  • 深入研究网络架构：ResNet, EfficientNet, Vision Transformer (ViT)。
  • 学习高级技术：标签平滑、知识蒸馏、自监督学习（如SimCLR, MoCo）。
  • 探索应用：细粒度图像分类、多标签分类、度量学习。

• 目标检测方向：

  • 掌握经典算法：深入理解Faster R-CNN（两阶段）、SSD、YOLO系列（v3, v5, v8, v10）的原理与实现细节。
  • 学习改进策略：FPN（特征金字塔）、注意力机制（如CBAM）、Anchor-Free检测器（如FCOS, CenterNet）。
  • 探索3D目标检测：点云数据处理、基于视觉的3D检测。

• 图像分割方向：

  • 掌握网络变体：DeepLab系列（空洞卷积）、PSPNet（金字塔池化）、Mask R-CNN（实例分割）。
  • 学习Transformer：SegFormer, SETR, 以及最新的SAM（Segment Anything Model）。
  • 探索应用：医学图像分割、遥感图像分割、视频语义分割。

• 通用能力：

  • 扎实的数学基础：线性代数、概率论、微积分。
  • 编程与框架：精通Python，深入理解PyTorch/TensorFlow的自动求导机制。
  • 阅读论文：养成阅读CVPR, ICCV, ECCV, NeurIPS等顶会论文的习惯，关注SOTA模型。
  • 参与竞赛：在Kaggle, 天池等平台参加计算机视觉相关比赛，这是提升实战能力最快的方式。

计算机视觉是一个快速发展的领域，保持持续学习和动手实践是关键。希望这篇从基础到实战的长文，能成为你CV之旅的一块坚实垫脚石。从运行文中的第一个代码块开始，祝你编码愉快！