思路分析

导入库是所有Python程序的第一步。OpenCV 库在 Python 中的导入名不是"opencv"，而是"cv2"。这个名称来源于OpenCV的C++ API版本号（C++ API是第2版，因此叫cv2）。

代码实现

import cv2

代码详解

import cv2 将OpenCV库导入到当前Python环境中。导入后，我们可以通过 cv2.函数名 的方式调用OpenCV的所有功能。

验证

可以在导入后添加一行代码来验证OpenCV是否安装成功：

import cv2
print("OpenCV版本:", cv2.__version__)

思路分析

读取图像使用 cv2.imread() 函数。该函数接收一个文件路径参数，返回一个NumPy数组（表示图像的像素矩阵）。需要注意路径的正确性——如果文件路径错误，imread 不会报错，而是返回 None，这在后续操作中会导致难以调试的错误。

代码实现

image = cv2.imread('data/butterfly.jpg')

代码详解

• cv2.imread('data/butterfly.jpg')：读取 data 文件夹下的 butterfly.jpg 文件
• 返回值是一个三维NumPy数组，形状为 (高度, 宽度, 3)，其中3表示BGR三个通道
• 将读取结果赋值给变量 image，后续操作都基于这个变量

验证

import cv2

image = cv2.imread('data/butterfly.jpg')

# 检查是否读取成功
if image is None:
    print("错误：图像读取失败，请检查文件路径！")
else:
    print("图像读取成功！")
    print("图像形状:", image.shape)  # (高, 宽, 通道数)
    print("图像数据类型:", image.dtype)  # uint8

思路分析

这道题考查两个知识点：（1）BGR到RGB的颜色空间转换；（2）使用matplotlib显示图像。

如前所述，OpenCV读取的图像是BGR格式，而matplotlib显示图像时默认使用RGB格式。如果不转换，图像中的红色和蓝色会颠倒。转换使用 cv2.cvtColor() 函数，指定转换码为 cv2.COLOR_BGR2RGB。

matplotlib 显示图像使用 plt.imshow() 函数，配合 plt.show() 显示。

代码实现

import matplotlib.pyplot as plt

# 将 BGR 转换为 RGB
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# 使用 matplotlib 展示图像
plt.imshow(image_rgb)
plt.title('Original Image')
plt.axis('off')  # 隐藏坐标轴
plt.show()

代码详解

• import matplotlib.pyplot as plt：导入matplotlib的绘图模块，约定俗成缩写为 plt
• cv2.cvtColor(image, cv2.COLOR_BGR2RGB)：颜色空间转换函数。第一个参数是输入图像，第二个参数指定转换类型。COLOR_BGR2RGB 表示从BGR转到RGB
• plt.imshow(image_rgb)：将图像数据显示在绘图区域中
• plt.title('Original Image')：设置图像标题
• plt.axis('off')：隐藏坐标轴刻度，让图像显示更干净
• plt.show()：渲染并显示图像。在Jupyter Notebook中，这行代码会触发图像的内联显示

思路分析

灰度化是将三通道的彩色图像转换为单通道的灰度图像。使用 cv2.cvtColor() 函数，转换码为 cv2.COLOR_BGR2GRAY。转换后图像从三维数组（H, W, 3）变为二维数组（H, W）。

代码实现

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

代码详解

• cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)：将BGR彩色图像转换为灰度图像
• OpenCV内部使用公式 Gray = 0.299R + 0.587G + 0.114B 进行转换
• 返回的 gray_image 是一个二维NumPy数组，形状为 (高度, 宽度)，没有通道维度
• 赋值给变量 gray_image，后续的滤波、边缘检测等操作将基于灰度图像进行

验证

print("彩色图像形状:", image.shape)      # 例如: (400, 400, 3)
print("灰度图像形状:", gray_image.shape)  # 例如: (400, 400)

# 显示灰度图像
plt.imshow(gray_image, cmap='gray')
plt.title('Gray Image')
plt.axis('off')
plt.show()

思路分析

高斯模糊使用 cv2.GaussianBlur() 函数。需要指定三个关键参数：输入图像、高斯核大小（ksize）、X方向标准差（sigmaX）。

题目要求"高斯核大小设置为5×5"，即 ksize=(5, 5)。"自动计算X方向标准差"意味着将 sigmaX 设为 0，OpenCV会根据核大小自动计算合适的标准差。

代码实现

blurred = cv2.GaussianBlur(gray_image, (5, 5), 0)

代码详解

• cv2.GaussianBlur(src, ksize, sigmaX)：高斯模糊函数
• 第一个参数 gray_image：输入图像（灰度图像）
• 第二个参数 (5, 5)：高斯核大小，必须为正奇数。核越大，模糊效果越明显。5×5表示在5×5的窗口内进行高斯加权平均
• 第三个参数 0：X方向标准差 sigmaX。设为0时，OpenCV自动根据核大小计算标准差（公式：σ = 0.3×((ksize-1)×0.5 - 1) + 0.8）
• 返回值赋给 blurred，即模糊后的图像

验证

# 对比显示原始灰度图和高斯模糊后的图像
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

axes[0].imshow(gray_image, cmap='gray')
axes[0].set_title('Original Gray')
axes[0].axis('off')

axes[1].imshow(blurred, cmap='gray')
axes[1].set_title('Gaussian Blurred (5x5)')
axes[1].axis('off')

plt.show()

思路分析

Canny边缘检测使用 cv2.Canny() 函数，需要指定输入图像、低阈值和高阈值。题目明确给出了阈值参数值：低阈值100，高阈值200。

注意：题目要求对模糊后的图像 blurred 进行边缘检测，而不是原始灰度图像。先滤波再检测边缘是标准流程——滤波可以减少噪声对边缘检测的干扰。

代码实现

edges = cv2.Canny(blurred, 100, 200)

代码详解

• cv2.Canny(image, threshold1, threshold2)：Canny边缘检测函数
• 第一个参数 blurred：输入图像（高斯模糊后的灰度图像）
• 第二个参数 100：低阈值（threshold1）。梯度值低于此值的像素被丢弃
• 第三个参数 200：高阈值（threshold2）。梯度值高于此值的像素被标记为强边缘
• 梯度值在100~200之间的像素，只有与强边缘相连时才被保留
• 返回的 edges 是一个二值图像：边缘像素为255（白色），非边缘像素为0（黑色）

思路分析

二值化使用 cv2.threshold() 函数。该函数返回两个值：第一个是使用的阈值（与输入阈值相同），第二个是二值化后的图像。题目要求将二值化图像赋值给 thresh，阈值可以忽略（用 _ 接收）。

参数：阈值=127，最大值=255，二值化类型使用 cv2.THRESH_BINARY（标准二值化：大于阈值设为最大值，小于阈值设为0）。

代码实现

_, thresh = cv2.threshold(gray_image, 127, 255, cv2.THRESH_BINARY)

代码详解

• cv2.threshold(src, thresh, maxval, type)：阈值分割函数
• 第一个参数 gray_image：输入图像（灰度图像）
• 第二个参数 127：阈值。像素值大于127的设为最大值，小于等于127的设为0
• 第三个参数 255：最大值。满足阈值条件时赋予的值
• 第四个参数 cv2.THRESH_BINARY：二值化类型。表示标准二值化
• 返回值：函数返回一个元组 (ret, dst)。ret 是实际使用的阈值（本题中就是127），dst 是二值化后的图像。使用 _ 接收第一个返回值表示忽略它，thresh 接收二值化图像

思路分析

保存图像使用 cv2.imwrite() 函数。该函数接收两个参数：保存路径（含文件名）和图像数据。需要分别保存四张图像。

代码实现

cv2.imwrite('data/gray_image.jpg', gray_image)
cv2.imwrite('data/blurred.jpg', blurred)
cv2.imwrite('data/edges.jpg', edges)
cv2.imwrite('data/thresh.jpg', thresh)

代码详解

• cv2.imwrite(path, image)：将图像保存到指定路径
• 第一个参数是保存路径（字符串），包含文件夹路径和文件名
• 第二个参数是要保存的图像数据（NumPy数组）
• 函数返回 True 表示保存成功，False 表示失败
• 保存的图像格式由文件扩展名决定：.jpg 为JPEG格式，.png 为PNG格式

思路分析

这是最基础的导入操作。torchvision 是 PyTorch 的视觉工具库，包含三个核心子模块：datasets（数据集加载）、transforms（数据变换）、models（预训练模型）。

代码实现

from torchvision import datasets, transforms, models

代码详解

• datasets：提供常用数据集的下载和加载功能，以及 ImageFolder 用于加载自定义文件夹数据
• transforms：提供图像预处理功能，如缩放、裁剪、归一化、转张量等
• models：提供预训练模型，如 MobileNetV2, ResNet, VGG 等

思路分析

数据预处理是深度学习中非常重要的一步。transforms.Compose() 可以将多个预处理操作串联成一个流程。题目要求三个操作：（1）缩放到200×200；（2）转为张量；（3）用ImageNet统计量归一化。

归一化的目的是将像素值从0~255的范围缩放到以0为中心的范围内，这有助于模型训练时梯度下降的稳定性。使用ImageNet的均值和标准差是因为我们使用的是在ImageNet上预训练的模型。

代码实现

transform = transforms.Compose([
    transforms.Resize((200, 200)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

代码详解

• transforms.Compose([...])：将列表中的变换操作按顺序组合成一个流水线。图像会依次通过每个变换
• transforms.Resize((200, 200))：将图像缩放到200×200像素。无论原图是什么尺寸，输出统一为200×200
• transforms.ToTensor()：将PIL图像或NumPy数组转为PyTorch张量。同时会将像素值从0~255缩放到0.0~1.0（除以255），并将通道维度从(H,W,C)调整为(C,H,W)
• transforms.Normalize(mean, std)：对张量进行归一化。公式：(x - mean) / std。使用ImageNet的统计量是因为预训练模型就是在这些统计量上训练的

思路分析

这道题包含两步操作：（1）用 ImageFolder 加载数据集；（2）用 DataLoader 创建批量加载器。

ImageFolder 会自动扫描目录下的子文件夹，每个子文件夹名作为一个类别。 DataLoader 负责将数据集分成小批量（batch），在训练时逐批提供数据。

代码实现

from torch.utils.data import DataLoader

train_dataset = datasets.ImageFolder('data/NEU-DET/train/images', transform=transform)

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)

代码详解

• datasets.ImageFolder('data/NEU-DET/train/images', transform=transform)：从指定目录加载图像数据。transform 参数指定预处理流程，加载时自动应用
• DataLoader(train_dataset, batch_size=16, shuffle=True)：创建数据加载器
• batch_size=16：每批16张图片。训练时模型每次处理16张图片而不是全部数据，这既节省内存又能让梯度下降更稳定
• shuffle=True：每个epoch开始时打乱数据顺序。这很重要——如果不打乱，模型可能记住数据的排列顺序而不是学习特征

# 查看数据集信息
print("训练集大小:", len(train_dataset))
print("类别名称:", train_dataset.classes)
print("类别映射:", train_dataset.class_to_idx)

# 获取一个批次的数据
images, labels = next(iter(train_loader))
print("一个批次的图像形状:", images.shape)   # torch.Size([16, 3, 200, 200])
print("一个批次的标签:", labels)

思路分析

使用 models.mobilenet_v2(pretrained=True) 加载预训练模型。然后修改模型的第一层卷积层 features[0][0]，用新的 nn.Conv2d 替换它。新的卷积层参数：输入通道32（原为3）、输出通道32、卷积核3×3、步长2、填充1。

代码实现

import torch.nn as nn

base_model = models.mobilenet_v2(pretrained=True)

# 修改第一层卷积
base_model.features[0][0] = nn.Conv2d(
    3, 32, kernel_size=3, stride=2, padding=1, bias=False
)

代码详解

• models.mobilenet_v2(pretrained=True)：加载在ImageNet上预训练的MobileNetV2。pretrained=True 表示加载预训练权重
• base_model.features[0][0]：访问模型的第一个特征提取模块中的第一个卷积层。MobileNetV2 的 features 是一个 nn.Sequential，features[0] 是第一个块（也是一个Sequential），features[0][0] 是其中的卷积层
• nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1, bias=False)：创建新的卷积层
• 3：输入通道数。虽然题目说"将输入通道从3改为32"，但实际上输入通道仍然是3（RGB图像），输出通道改为32。这里理解题目意图：修改卷积层的参数配置
• 32：输出通道数（卷积核数量）
• kernel_size=3：卷积核大小3×3
• stride=2：步长2，卷积核每次移动2个像素，使输出尺寸减半
• padding=1：填充1，在图像边缘补一圈0，保证卷积后尺寸计算正确
• bias=False：不使用偏置。MobileNetV2的卷积层后接BN层，BN层已包含偏置功能，因此卷积层不需要额外的偏置

思路分析

迁移学习的第一阶段是"特征提取"——冻结卷积基的所有参数，只训练新添加的分类头。PyTorch 中通过设置 requires_grad=False 来冻结参数，使优化器在反向传播时不会更新这些参数。

代码实现

for param in base_model.parameters():
    param.requires_grad = False

代码详解

• base_model.parameters()：返回模型所有参数的迭代器
• param.requires_grad = False：将每个参数的 requires_grad 属性设为 False，表示该参数不需要计算梯度，因此在反向传播时不会被更新
• 这样做的好处：（1）减少计算量，训练更快；（2）保护预训练的特征提取能力不被破坏；（3）减少需要训练的参数量，降低过拟合风险

思路分析

这是一个完整的模型构建任务。使用 nn.Sequential 将各层按顺序串联。模型结构从预训练的base_model开始，经过自适应平均池化、展平、两个全连接层（中间有ReLU激活和Dropout），最终输出6个类别的分数。

代码实现

model = nn.Sequential(
    base_model,
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten(),
    nn.Linear(1280, 256),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(256, 6)
)

代码详解

• nn.Sequential(...)：按顺序组合各层，数据从第一层开始依次通过每一层
• base_model：预训练的MobileNetV2特征提取器。输出形状为 (batch, 1280, H, W)
• nn.AdaptiveAvgPool2d((1, 1))：自适应平均池化，将空间维度压缩到1×1。无论输入H×W多大，输出都是1×1。输出形状变为 (batch, 1280, 1, 1)
• nn.Flatten()：展平多维张量为一维。(batch, 1280, 1, 1) → (batch, 1280)
• nn.Linear(1280, 256)：全连接层，将1280维特征映射到256维。这是第一个分类层的权重矩阵
• nn.ReLU()：ReLU激活函数，引入非线性。ReLU(x) = max(0, x)
• nn.Dropout(0.5)：训练时随机丢弃50%的神经元，防止过拟合。测试时自动关闭
• nn.Linear(256, 6)：最后一个全连接层，将256维特征映射到6维（对应6类缺陷）。输出的是每类的原始分数

思路分析

训练深度学习模型需要三个核心组件：损失函数（衡量预测与真实值的差距）、优化器（根据梯度更新参数）、学习率调度器（动态调整学习率）。

代码实现

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)

代码详解

• nn.CrossEntropyLoss()：交叉熵损失函数。这是多分类任务的标准损失函数。它内部集成了Softmax操作，因此模型的输出不需要提前经过Softmax
• optim.Adam(model.parameters(), lr=0.001)：Adam优化器。
• model.parameters()：传入需要优化的参数（只有requires_grad=True的参数会被优化）
• lr=0.001：学习率，控制每次参数更新的步长。0.001是Adam的常用默认值
• optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9)：指数衰减学习率调度器。每个epoch后学习率乘以gamma（0.9），即学习率按指数逐渐减小

思路分析

这是迁移学习第二阶段——微调（Fine-Tuning）的准备工作。先解冻所有参数（requires_grad=True），然后只冻结前50层（保留低层通用特征），让高层特征参与微调以适应钢材缺陷检测任务。

代码实现

# 第一步：解冻所有参数
for param in base_model.parameters():
    param.requires_grad = True

# 第二步：冻结前50层
for i, param in enumerate(base_model.parameters()):
    if i < 50:
        param.requires_grad = False

代码详解

• 第一步遍历所有参数并设为 True，恢复梯度计算
• 第二步使用 enumerate 获取参数的序号和值。前50个参数（序号0~49）设为 False（冻结），其余保持 True（可训练）
• 这样做的效果：MobileNetV2的低层（提取边缘、纹理等通用特征）保持冻结，高层（提取更抽象的特征）参与微调，适应钢材缺陷检测任务

思路分析

微调阶段使用更小的学习率（0.0001 vs 第一阶段的0.001），因为此时是在已有预训练权重的基础上做精细调整，大学习率可能破坏已学到的特征。需要只优化 requires_grad=True 的参数。

代码实现

optimizer_fine = optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=0.0001
)

代码详解

• filter(lambda p: p.requires_grad, model.parameters())：过滤出所有 requires_grad=True 的参数。filter 函数根据条件筛选可迭代对象中的元素
• lambda p: p.requires_grad：匿名函数，判断参数是否需要梯度。返回 True 的参数被保留
• optim.Adam(..., lr=0.0001)：创建新的Adam优化器，学习率为0.0001（比第一阶段小10倍）
• 只优化需要训练的参数，可以减少计算量并避免意外修改冻结的参数

思路分析

训练完成后需要保存模型参数，以便后续加载使用（如推理预测）。PyTorch 使用 torch.save() 保存模型，推荐只保存参数字典（state_dict）而不是整个模型对象。

代码实现

torch.save(model.state_dict(), 'neu_model.pth')

代码详解

• model.state_dict()：返回模型所有参数的字典。键是层名，值是对应的参数张量
• torch.save(obj, path)：将对象保存到文件。.pth 或 .pt 是PyTorch模型文件的常用扩展名
• 保存的是参数字典而非整个模型，这样更灵活——加载时需要先创建相同结构的模型，再加载参数

# 加载模型参数的完整流程
model = nn.Sequential(...)  # 先创建相同结构的模型
model.load_state_dict(torch.load('neu_model.pth'))
model.eval()  # 切换到评估模式（关闭Dropout等）

思路分析

这是深度学习项目的标准开头——检测GPU是否可用，并选择计算设备。有GPU时使用GPU（训练快很多），没有时使用CPU。使用三元表达式在一行代码中完成条件判断和赋值。

代码实现

import torch

DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

代码详解

• torch.cuda.is_available()：检测系统是否有可用的NVIDIA GPU及CUDA环境。返回 True 或 False
• 'cuda' if torch.cuda.is_available() else 'cpu'：Python 三元表达式。条件为真返回 'cuda'，否则返回 'cpu'
• torch.device(...)：创建设备对象。后续可以将模型和数据通过 .to(DEVICE) 移动到指定设备上
• 将设备对象赋值给 DEVICE，在整个项目中统一使用

思路分析

Tokenizer（分词器）负责将文本转换为模型能理解的数字ID。from_pretrained 方法会自动从HuggingFace Hub下载指定模型的分词器配置和词表。

代码实现

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained(MODEL_NAME)

代码详解

• BertTokenizer：BERT的分词器类，专门处理BERT格式的分词
• from_pretrained(MODEL_NAME)：从预训练模型加载分词器。MODEL_NAME 是模型名称字符串（如 'huawei-noah/TinyBERT_General_4L_312D'）。首次使用时会自动下载，之后从本地缓存加载
• 赋值给 tokenizer，后续用它将中文评论文本转换为BERT输入格式

# 分词器使用示例
text = "这个商品很好用"
encoding = tokenizer(text, max_length=128, padding='max_length', truncation=True, return_tensors='pt')

print("input_ids:", encoding['input_ids'])
# tensor([[101, 6821, 7028, 765, 3766, 1962, 4680, 102, 0, 0, ...]])
# 101=[CLS], 102=[SEP], 0=[PAD]

print("attention_mask:", encoding['attention_mask'])
# tensor([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
# 1=有效词, 0=填充

思路分析

这是一个简单的对象实例化操作。SentimentDataset 是竞赛环境中预定义的自定义数据集类（继承自 torch.utils.data.Dataset），接收文本列表、标签列表、分词器和最大长度作为参数。

代码实现

val_dataset = SentimentDataset(val_texts, val_labels, tokenizer, MAX_LEN)

代码详解

• SentimentDataset(...)：创建验证数据集实例
• val_texts：验证集文本列表，如 ['很好用', '质量差', ...]
• val_labels：验证集标签列表，如 [1, 0, ...]（1=正面，0=负面）
• tokenizer：上一步加载的BertTokenizer，用于在数据集内部将文本转为ID序列
• MAX_LEN：最大序列长度，超长截断，不足填充

class SentimentDataset(torch.utils.data.Dataset):
    def __init__(self, texts, labels, tokenizer, max_len):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, item):
        text = self.texts[item]
        label = self.labels[item]
        encoding = self.tokenizer(text, max_length=self.max_len,
                       padding='max_length', truncation=True,
                       return_tensors='pt')
        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

思路分析

与模块B中的DataLoader使用方式相同，只是这里是NLP数据集。创建DataLoader时指定批次大小和是否打乱顺序。

代码实现

from torch.utils.data import DataLoader

train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)

代码详解

• DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)：创建训练数据加载器
• train_dataset：训练数据集（SentimentDataset实例）
• batch_size=BATCH_SIZE：使用预定义的批次大小（通常为32）
• shuffle=True：打乱数据顺序，防止模型学习到数据的排列规律

思路分析

BertForSequenceClassification 是HuggingFace提供的BERT序列分类模型，在BERT的基础上内置了一个线性分类头。num_labels=2 指定二分类任务（正面/负面）。

代码实现

from transformers import BertForSequenceClassification

model = BertForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=2)

代码详解

• BertForSequenceClassification：BERT序列分类模型类。它在BERT编码器之上添加了一个线性分类层，直接输出分类结果
• from_pretrained(MODEL_NAME, num_labels=2)：加载预训练模型。num_labels=2 指定分类头输出2维（对应正面/负面两个类别）
• 模型会自动在BERT编码器顶部添加一个线性分类层，将[CLS]标记的隐藏状态映射到2维输出
• 赋值给 model，后续通过 model.to(DEVICE) 移动到GPU或CPU

思路分析

AdamW 是 Transformer 模型训练的标准优化器。2e-5（即0.00002）是BERT微调的推荐学习率，比CNN训练用的学习率小得多，因为预训练语言模型的权重已经很好，只需要轻微调整。

代码实现

from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8)

代码详解

• AdamW：Adam优化器的改进版本，修正了权重衰减的实现。Transformers库提供的AdamW与PyTorch内置的 torch.optim.AdamW 功能相同
• model.parameters()：传入模型所有需要优化的参数
• lr=2e-5：学习率。科学计数法，2×10⁻⁵ = 0.00002。BERT微调的典型学习率范围是2e-5到5e-5
• eps=1e-8：数值稳定性常数。防止分母为零的情况，1e-8是默认推荐值

思路分析

Warmup 步数是训练初期学习率从0线性增长到预设值的步数。通常设为总步数的10%（WARMUP_RATIO=0.1）。需要将浮点数结果取整，因为步数必须是整数。

代码实现

warmup_steps = int(WARMUP_RATIO * total_steps)

代码详解

• WARMUP_RATIO * total_steps：预热比例乘以总训练步数，得到浮点数结果。例如 total_steps=1000, WARMUP_RATIO=0.1，结果为100.0
• int(...)：将浮点数取整为整数。例如 100.0 → 100
• 赋值给 warmup_steps，用于后续构建学习率调度器

# 总训练步数 = 每轮步数 × 训练轮数
# 每轮步数 = 数据量 ÷ 批次大小（向上取整）
total_steps = len(train_loader) * EPOCHS

思路分析

训练循环中，每个batch是一个字典，包含 input_ids、attention_mask 和 labels。需要将标签数据移到与模型相同的设备（GPU/CPU）上才能进行计算。

代码实现

labels = batch['labels'].to(device)

代码详解

• batch['labels']：从batch字典中获取键为 'labels' 的张量（真实标签）
• .to(device)：将张量移动到指定设备。如果 device 是 'cuda'，张量被移到GPU；如果是 'cpu'，保持在CPU上
• 赋值给 labels，用于后续计算损失和评估准确率

思路分析

验证阶段收集所有预测结果。GPU上的张量不能直接转换为Python列表，需要先移到CPU。extend 方法可以将一个列表的所有元素添加到另一个列表中。

代码实现

predictions.extend(preds.cpu().tolist())

代码详解

• preds.cpu()：将GPU上的预测张量转移到CPU。这一步是必须的——GPU张量不能直接调用 .tolist()
• .tolist()：将张量转换为Python列表。例如 tensor([1, 0, 1]) → [1, 0, 1]
• predictions.extend(...)：将列表中的所有元素逐个添加到 predictions 列表末尾。注意 extend 和 append 的区别：extend([1,0,1]) 添加三个元素，append([1,0,1]) 添加一个列表作为单个元素

思路分析

训练过程中通常会保存验证集上表现最好的模型权重。训练结束后，需要将最优权重重新加载到模型中，以获得最佳性能的模型用于推理。

代码实现

model.load_state_dict(best_model_state)

代码详解

• best_model_state：存储最优模型参数的状态字典（通常在训练循环中通过 best_model_state = model.state_dict() 保存）
• model.load_state_dict(best_model_state)：将状态字典中的参数值加载到模型的对应层中，覆盖当前参数
• 加载后模型恢复到验证集上表现最好的状态，而不是最后一个epoch的状态（最后一个epoch可能过拟合）

思路分析

竞赛环境中预定义了 train_model 函数，封装了 YOLOv8 的训练逻辑（包括冻结主干、设置余弦退火调度、关闭Mosaic等）。只需调用该函数即可启动训练。

代码实现

train_model()

代码详解

• train_model()：调用预定义的训练函数。该函数内部完成：加载YOLOv8n预训练模型→冻结主干参数→配置余弦退火学习率→关闭Mosaic增强→执行训练循环→保存最优权重
• 训练过程中会在控制台输出每个epoch的损失、学习率、mAP等指标

思路分析

YOLOv8 的 model.val() 方法用于在验证集上评估模型性能。需要传入多个配置参数，所有参数从配置对象 cfg 中获取。verbose=False 关闭详细输出。

代码实现

metrics = model.val(
    data=cfg.YAML_PATH,
    imgsz=cfg.IMGSZ,
    batch=cfg.BATCH_SIZE,
    device=cfg.DEVICE,
    conf=cfg.VAL_CONF,
    iou=cfg.IOU_THRESHOLD,
    verbose=False
)

代码详解

• model.val(...)：YOLOv8 模型验证方法，在验证集上计算 mAP、精确率、召回率等指标
• data=cfg.YAML_PATH：数据集配置文件路径，指定验证集位置和类别信息
• imgsz=cfg.IMGSZ：输入图像尺寸（如640），模型会将图像缩放到此尺寸
• batch=cfg.BATCH_SIZE：验证时的批次大小
• device=cfg.DEVICE：计算设备（如 'cuda:0' 或 'cpu'）
• conf=cfg.VAL_CONF：置信度阈值，低于此值的检测结果被过滤
• iou=cfg.IOU_THRESHOLD：NMS（非极大值抑制）的IoU阈值，用于去除重叠框
• verbose=False：关闭详细输出，只返回指标不打印日志
• 返回值赋给 metrics，包含 mAP@0.5、mAP@0.5:0.95、精确率、召回率等

思路分析

竞赛环境预定义了 evaluate_model 函数，用于在验证集上评估不同epoch保存的权重，返回表现最优的权重文件路径。

代码实现

best_weight_path = evaluate_model()

代码详解

• evaluate_model()：预定义的评估函数，遍历训练过程中保存的权重文件，在验证集上逐一评估，返回mAP最高的权重路径
• 赋值给 best_weight_path，后续用于加载最优模型进行推理

思路分析

使用 cv2.resize() 缩放图像。目标尺寸通过将原始宽高乘以缩放比例并取整得到。int() 确保尺寸为整数（resize函数要求整数尺寸）。

代码实现

display_img = cv2.resize(display_img, (int(w_disp * scale), int(h_disp * scale)))

代码详解

• cv2.resize(src, dsize)：图像缩放函数。src 是输入图像，dsize 是目标尺寸元组 (width, height)
• w_disp * scale：原始宽度乘以缩放比例。例如 w_disp=1920, scale=0.5 → 960.0
• int(...)：取整。resize要求尺寸为整数，960.0 → 960
• 目标尺寸元组 (int(w_disp * scale), int(h_disp * scale)) 同时指定了宽和高
• 缩放结果重新赋值给 display_img，覆盖原图像数据

思路分析

竞赛环境预定义了 predict_and_analyze 函数，用于加载最优权重、对样本图像进行推理预测，并可视化分析结果。需要传入权重路径和样本数量。

代码实现

predict_and_analyze(best_weight_path, num_samples=2)

代码详解

• predict_and_analyze(...)：预定义的预测分析函数
• best_weight_path：作为位置参数传入，指定最优权重文件路径
• num_samples=2：关键字参数，指定分析2个样本图像。关键字参数的格式是 参数名=值
• 函数内部：加载权重→选取样本→模型推理→绘制检测框→输出分析结果

思路分析

psutil.cpu_count(logical=False) 返回物理CPU核心数。logical=False 表示不计算超线程核心。

代码实现

import psutil

cpu_count = psutil.cpu_count(logical=False)

代码详解

• psutil.cpu_count(logical=False)：获取物理CPU核心数
• logical=False：不计算超线程。例如4核8线程的CPU，logical=False 返回4，logical=True 返回8
• 赋值给 cpu_count，用于后续设置 DataLoader 的 num_workers 参数

思路分析

竞赛环境预定义了环境检查函数（如 check_environment），用于验证GPU、内存、依赖库等是否满足训练要求。

代码实现

check_environment()

代码详解

• check_environment()：调用预定义的环境检查函数
• 该函数检查：PyTorch版本、CUDA可用性、GPU显存、磁盘空间、依赖库完整性等
• 如果环境不满足要求，函数会输出警告信息

思路分析

random.sample(population, k) 从列表中随机抽取k个不重复元素。需要处理数据量不足200的情况——取 min(200, len(train_imgs)) 确保不超过列表长度。

代码实现

import random

sample_imgs = random.sample(train_imgs, min(200, len(train_imgs)))

代码详解

• random.sample(population, k)：从 population 中随机选取 k 个不重复元素，返回新列表
• train_imgs：训练图像路径列表
• min(200, len(train_imgs))：取200和列表长度的较小值。如果列表只有150张图，则取150；如果有1000张，则取200
• 这样做的目的是防止当数据量不足200时 random.sample 报 ValueError: Sample larger than population

思路分析

分两步操作：（1）用 cv2.imread() 读取图像（BGR格式）；（2）用 cv2.cvtColor() 将BGR转为RGB。这是模块A学过的操作的直接应用。

代码实现

img = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)

代码详解

• cv2.imread(img_path)：读取指定路径的图像，返回BGR格式的NumPy数组
• cv2.cvtColor(..., cv2.COLOR_BGR2RGB)：将BGR转为RGB。这在用matplotlib显示图像时是必须的
• 两步操作可以嵌套在一行中完成：先 imread 再 cvtColor
• 赋值给 img，用于后续的可视化展示

思路分析

竞赛环境预定义了 visualize_ground_truth 函数，用于在图像上绘制标注框（ground truth）并显示。通过关键字参数指定样本数量。

代码实现

visualize_ground_truth(num_samples=2)

代码详解

• visualize_ground_truth(...)：预定义的可视化函数，在样本图像上绘制真实标注框
• num_samples=2：关键字参数，指定可视化2个样本。关键字参数格式为 参数名=值
• 该函数通常用于训练前检查数据标注是否正确

思路分析

使用 Ultralytics 的 YOLO 类加载模型。模型名称存储在配置对象 cfg.MODEL_NAME 中（如 'yolov8n.pt'）。

代码实现

from ultralytics import YOLO

model = YOLO(cfg.MODEL_NAME)

代码详解

• YOLO(cfg.MODEL_NAME)：实例化YOLO模型。cfg.MODEL_NAME 是模型名称/路径，如 'yolov8n.pt'
• 如果传入的是预训练权重文件名（如 yolov8n.pt），Ultralytics 会自动下载（首次使用时）并加载COCO预训练权重
• 赋值给 model，后续调用 model.train()、model.val()、model.predict() 等方法