Replies: 103 comments 119 replies
-
|
编号：2503-07 计算机视觉应用实验报告：基于 CNN/ResNet 的 CIFAR-10 图像分类
一、实验目标本实验选择“自然图像分类”作为计算机视觉应用场景，使用深度卷积神经网络对 CIFAR-10 数据集中的图像进行分类识别。实验目标如下：
二、数据集介绍本实验使用 CIFAR-10 数据集。CIFAR-10 是计算机视觉领域常用的图像分类数据集，包含 10 个类别的彩色自然图像。
与 MNIST 手写数字相比，CIFAR-10 图像背景更复杂，类别间差异更细，适合用于展示计算机视觉模型对颜色、纹理、边缘和语义特征的提取能力。 三、数据预处理方法为了提高模型泛化能力，实验对训练集进行数据增强，对测试集只进行标准化处理，确保测试结果稳定。
标准化参数采用 CIFAR-10 常用设置： mean = (0.4914, 0.4822, 0.4465)
std = (0.2470, 0.2435, 0.2616)数据预处理代码示例： transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2470, 0.2435, 0.2616))
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2470, 0.2435, 0.2616))
])四、模型架构本实验采用适配 CIFAR-10 小尺寸图像的 ResNet-18 模型。原始 ResNet-18 通常用于较大尺寸图像，因此实验中对第一层卷积和池化结构进行了调整：
模型构建代码示例： import torch.nn as nn
from torchvision import models
def build_model(num_classes=10):
model = models.resnet18(weights=None)
model.conv1 = nn.Conv2d(
3, 64, kernel_size=3, stride=1, padding=1, bias=False
)
model.maxpool = nn.Identity()
model.fc = nn.Linear(model.fc.in_features, num_classes)
return model五、训练过程训练过程使用交叉熵损失函数和 Adam 优化器。每个 epoch 完成后，在测试集上计算损失和准确率，并保存实验结果。
训练流程如下：
训练核心代码示例： def train_one_epoch(model, loader, criterion, optimizer, device):
model.train()
total_loss, correct, total = 0.0, 0, 0
for images, labels in loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item()
correct += (outputs.argmax(1) == labels).sum().item()
total += labels.size(0)
return total_loss / len(loader), correct / total六、代码实现与代码质量本实验代码实现时建议采用模块化结构，便于维护和复现实验：
代码质量评价：
七、实验结果展示下表为 10 轮训练的实验结果示例。可以看到，随着训练轮数增加，训练损失逐步下降，测试准确率持续提升。
图1 训练损失与测试准确率变化曲线 从图1可以看出，训练损失整体呈下降趋势，说明模型参数逐渐优化；测试准确率不断提高，说明模型在测试集上的泛化能力逐步增强。
图2 CIFAR-10 各类别测试准确率 从图2可以看出， 八、模型准确度分析本实验最终测试准确率约为 86.8%。对于 CIFAR-10 这类自然图像分类任务，该结果说明模型已经学习到了较有效的图像特征。
九、结果分析实验结果表明，深度卷积神经网络能够有效完成多类别自然图像分类任务。ResNet 的残差连接有助于训练更深层网络，使模型能够学习从边缘、纹理到语义类别的多层特征。 训练初期，模型对图像类别的区分能力较弱，因此准确率较低；随着训练进行，卷积层逐渐学习到类别相关特征，准确率明显提升。后期准确率提升速度变慢，说明模型逐渐接近当前结构和训练参数下的性能上限。 错误分类主要集中在视觉特征相似的类别。例如，猫和狗都属于动物类别，姿态、颜色和背景变化较大；鸟和鹿等类别在低分辨率图像中细节有限，也可能导致分类困难。 十、实验结论本实验完成了一个完整的计算机视觉图像分类应用。通过 CIFAR-10 数据集、数据增强、改进 ResNet-18 模型和规范训练流程，模型能够对 10 类自然图像进行较准确识别，最终测试准确率约为 86.8%。 实验说明：
十一、改进方向后续可以从以下方面继续优化：
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2503-07 分数：93.0/100 评语：报告结构完整、内容详实，技术理解深入，实验过程与结果展示清晰，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-05 项目目标与应用场景1.1 实验目标本实验旨在构建一个综合性的计算机视觉应用系统，包含以下核心目标：
1.2 应用场景本项目涉及的计算机视觉技术具有广泛的应用场景：
数据集与数据处理2.1 CIFAR-10数据集介绍CIFAR-10是一个常用的图像分类基准数据集，包含10个类别的60000张32x32彩色图像：
2.2 数据集特点
2.3 数据预处理方法# 数据加载
(x_train, y_train), (x_test, y_test) = datasets.cifar10.load_data()
# 归一化处理：将像素值从[0,255]缩放到[0,1]
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0
# 标签编码：转换为独热向量
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)2.4 实时检测数据集对于实时颜色检测，使用OpenCV捕获的摄像头视频流，无需预定义数据集。 模型或技术方案3.1 图像分类模型架构采用Advanced CNN架构，包含以下核心组件： 3.2 技术选择原因3.2.1 深度卷积神经网络相比传统机器学习方法，CNN能够自动学习图像的层次化特征表示：
3.2.2 Batch Normalization（批归一化）
3.2.3 Dropout正则化
3.2.4 学习率调整策略使用ReduceLROnPlateau回调函数：
3.3 颜色检测技术方案采用HSV颜色空间的阈值分割方法： color_ranges = {
'Red': ((0, 100, 100), (10, 255, 255)),
'Green': ((35, 50, 50), (85, 255, 255)),
'Blue': ((90, 50, 50), (130, 255, 255)),
'Yellow': ((20, 100, 100), (30, 255, 255)),
'Orange': ((10, 100, 100), (20, 255, 255)),
'Purple': ((130, 50, 50), (170, 255, 255))
}HSV空间优势：
实现与训练过程4.1 开发环境配置# 所需库
pip install tensorflow matplotlib numpy opencv-python pillow4.2 训练过程详解4.2.1 模型编译model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='categorical_crossentropy',
metrics=['accuracy']
)
4.2.2 训练配置history = model.fit(
x_train, y_train,
epochs=20,
batch_size=64,
validation_split=0.1,
callbacks=[reduce_lr],
verbose=1
)
4.2.3 训练过程记录
4.3 实时颜色检测实现def detect_color(frame, color_name, lower_bound, upper_bound):
# 转换到HSV空间
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# 创建掩码
mask = cv2.inRange(hsv, np.array(lower_bound), np.array(upper_bound))
# 查找轮廓
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 标注检测到的目标
if contours:
largest_contour = max(contours, key=cv2.contourArea)
if cv2.contourArea(largest_contour) > 500:
x, y, w, h = cv2.boundingRect(largest_contour)
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
return True
return False实验结果5.1 CIFAR-10分类结果5.1.1 最终性能指标
5.1.2 分类混淆矩阵5.2 训练曲线
5.3 分类结果可视化
5.4 颜色检测结果
5.5 图像增强结果
5.6 关键代码文件
结果分析与总结6.1 实验结果分析6.1.1 模型性能分析
6.1.2 颜色检测效果
6.2 技术难点与解决方案6.2.1 CIFAR-10挑战难点：相比MNIST，CIFAR-10图像更小（32×32），但类别内差异更大 解决方案：
6.2.2 颜色检测挑战难点：光照变化影响颜色感知 解决方案：
6.3 改进方向
6.4 实验总结本次实验成功完成了一个综合性的计算机视觉应用系统：
该系统展示了计算机视觉在实际应用中的多样性和实用性，为进一步研究和应用奠定了基础。 6.5 技术收获通过本次实验，深入理解了：
这些知识和技能为未来从事计算机视觉相关工作打下了坚实基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-05 分数：93.0/100 评语：报告结构完整、内容详实，技术实现与分析深入，实验结果展示充分，具备较高可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-25 分数：93.0/100 评语：报告结构完整、内容详实，技术实现清晰，实验结果展示充分，具备良好的可复现性与分析深度。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
实践2：计算机视觉应用——基于ResNet的图像分类编号： 2501-03 1. 实验目的本实验旨在实现一个基于深度残差网络（ResNet）的图像分类系统，通过CIFAR-10数据集进行训练和测试，深入理解现代计算机视觉技术和深度残差学习的原理。 2. 实验环境
3. 数据集介绍CIFAR-10数据集CIFAR-10是一个经典的图像分类数据集，包含：
数据预处理
数据增强策略
4. ResNet模型设计4.1 残差学习原理深度神经网络训练存在梯度消失问题，ResNet通过引入残差连接解决这一问题： 其中 4.2 模型架构本实验采用ResNet-18架构：
4.3 残差块结构BasicBlock（基础残差块）： class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_channels, out_channels, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
self.downsample = downsample
self.stride = stride
def forward(self, x):
identity = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out4.4 ResNet完整实现class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=10):
super(ResNet, self).__init__()
self.in_channels = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
# 初始化...
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x5. 训练设置5.1 超参数配置
5.2 训练流程
6. 实验结果6.1 训练曲线训练过程中的损失和准确率变化曲线如下： 训练损失曲线
训练准确率曲线
6.2 测试结果
6.3 混淆矩阵混淆矩阵展示了模型在每个类别上的分类性能： 6.4 分类报告
6.5 结果分析
7. 代码结构8. 运行方式# 安装依赖
pip install -r requirements.txt
# 运行训练
python src/main.py运行后会生成：
9. 对比实验（可选）
10. 结论本实验成功实现了一个基于ResNet的图像分类系统，主要收获：
11. 参考文献
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-03 分数：95.0/100 评语：报告结构完整、内容详实，技术理解深入，代码与实验结果展示充分，具备良好可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-17 一、项目目标与应用场景1.1 项目目标本实验以自然图像分类为核心计算机视觉任务，基于卷积神经网络（CNN）与残差网络（ResNet）核心思想，完成CIFAR-10数据集的图像分类训练与验证。实验旨在掌握深度学习图像分类完整开发流程，理解卷积特征提取、残差结构原理、数据增强策略、模型训练机制与性能评估方法，具体目标如下：
1.2 应用场景图像分类是计算机视觉的基础任务，是目标检测、图像分割、图像检索等高级视觉任务的底层支撑。本实验训练的通用自然图像分类模型可落地于多种实际场景，包括智能监控物体分类、无人驾驶路况识别、移动端轻量化图像识别、智能家居视觉感知等。同时本实验的数据处理、模型调优与训练方案可迁移至各类图像识别项目，具备良好的工程实践价值。 二、数据集与数据处理2.1 数据集介绍本次实验使用 CIFAR-10 标准图像分类数据集，该数据集包含 50000 张训练图像与 10000 张测试图像，共 10 类彩色自然图像。图像尺寸为 32×32 的小尺寸 RGB 图像，画面背景复杂、类间相似度高，非常适合用于检验卷积神经网络的特征提取与泛化能力。 数据集信息汇总：
相比于 MNIST 手写数据集，CIFAR-10 色彩信息丰富、场景更复杂、分类难度更高，更贴合真实计算机视觉任务场景。 2.2 数据预处理与数据增强为避免模型过拟合、提升泛化能力、加速收敛，本实验采用训练集增强、测试集纯净预处理的标准策略：
测试集仅做标准化与张量转换，不做随机增强，保证测试指标稳定可信。 2.3 预处理代码mean = (0.4914, 0.4822, 0.4465)
std = (0.2470, 0.2435, 0.2616)
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean, std)
])三、模型或技术方案3.1 模型选型依据普通卷积神经网络在层数加深时容易出现梯度消失、网络退化问题，导致精度不升反降。ResNet 通过残差跳跃连接，让深层网络可以恒等映射，有效解决深层网络退化问题。 因此本实验选用 ResNet-18 作为基础模型，结构轻量、收敛速度快、适合小数据集训练。 3.2 模型结构改造原版 ResNet-18 适用于大尺寸图像，直接用于32×32图像会丢失大量细节，因此做如下适配改造：
3.3 模型结构层级
3.4 模型构建代码import torch.nn as nn
from torchvision import models
def build_model(num_classes=10):
model = models.resnet18(weights=None)
model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
model.maxpool = nn.Identity()
model.fc = nn.Linear(model.fc.in_features, num_classes)
return model四、实现与训练过程4.1 训练超参数设置
4.2 训练流程
4.3 核心训练代码def train_one_epoch(model, loader, criterion, optimizer, device):
model.train()
total_loss, correct, total = 0.0, 0, 0
for images, labels in loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item()
correct += (outputs.argmax(1) == labels).sum().item()
total += labels.size(0)
return total_loss / len(loader), correct / total五、实验结果5.1 训练指标数据本次实验共训练10轮，模型稳定收敛，训练损失持续下降，测试准确率稳步提升：
最终模型在测试集上达到 86.8% 准确率，收敛效果良好。 5.2 可视化结果分析
六、结果分析与总结6.1 实验总结本实验成功完成基于 ResNet-18 的 CIFAR-10 图像分类任务，搭建了完整的数据预处理、模型构建、训练迭代、结果评估的计算机视觉实验流程。通过对 ResNet 网络进行针对性改造，使其适配32×32小尺寸图像，最终模型测试准确率达到 86.8%，训练收敛稳定，泛化能力良好。 实验验证了：
6.2 存在问题
6.3 改进方向
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-17 分数：93.0/100 评语：报告结构完整、技术描述准确，实验流程清晰，结果展示充分，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-14 项目目标与应用场景项目目标本项目旨在基于 YOLOv8 目标检测模型，实现一个实时的摄像头目标检测系统，具体目标包括：
应用场景
数据集与数据处理数据集简介使用 COCO（Common Objects in Context）数据集，这是目前最常用的目标检测基准数据集：
数据预处理方法
标签格式转换将 COCO 格式转换为 YOLO 格式： def convert_coco_to_yolo(coco_annotation, image_width, image_height):
x_center = (coco_annotation['bbox'][0] + coco_annotation['bbox'][2] / 2) / image_width
y_center = (coco_annotation['bbox'][1] + coco_annotation['bbox'][3] / 2) / image_height
width = coco_annotation['bbox'][2] / image_width
height = coco_annotation['bbox'][3] / image_height
return f"{coco_annotation['category_id']} {x_center} {y_center} {width} {height}"模型或技术方案YOLOv8 模型架构选择 YOLOv8 作为目标检测模型，原因如下：
模型尺寸选择
技术栈
实现与训练过程项目结构Web 应用实现from flask import Flask, Response, render_template
import cv2
from ultralytics import YOLO
app = Flask(__name__)
model = YOLO('yolov8n.pt')
def gen_frames():
cap = cv2.VideoCapture(0)
while True:
success, frame = cap.read()
if not success:
break
results = model(frame)
annotated_frame = results[0].plot()
ret, buffer = cv2.imencode('.jpg', annotated_frame)
frame = buffer.tobytes()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
@app.route('/')
def index():
return render_template('index.html')
@app.route('/video_feed')
def video_feed():
return Response(gen_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5001)命令行版本实现import cv2
from ultralytics import YOLO
import argparse
from datetime import datetime
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--camera', type=int, default=0)
parser.add_argument('--conf', type=float, default=0.35)
parser.add_argument('--interval', type=int, default=2)
args = parser.parse_args()
model = YOLO('yolov8n.pt')
cap = cv2.VideoCapture(args.camera)
print("YOLO 命令行识别已启动。按 Ctrl+C 停止。")
print(f"模型：yolov8n.pt | 摄像头：{args.camera} | 置信度：{args.conf}")
last_print_time = datetime.now()
try:
while True:
success, frame = cap.read()
if not success:
break
results = model(frame, conf=args.conf)
current_time = datetime.now()
if (current_time - last_print_time).seconds >= args.interval:
detections = []
confidences = []
for box in results[0].boxes:
cls = model.names[int(box.cls[0])]
conf = float(box.conf[0])
detections.append(cls)
confidences.append(f"{cls} {conf:.2f}")
if detections:
print(f"[{current_time.strftime('%H:%M:%S')}] {' | '.join(detections)} | {' | '.join(confidences)}")
last_print_time = current_time
except KeyboardInterrupt:
print("\n检测已停止。")
finally:
cap.release()
if __name__ == '__main__':
main()训练过程（可选）from ultralytics import YOLO
model = YOLO('yolov8n.yaml') # 从头开始训练
results = model.train(
data='coco.yaml',
epochs=100,
imgsz=640,
batch=16,
lr0=0.01,
augment=True
)
# 验证模型
metrics = model.val()
# 导出模型
model.export(format='onnx')实验结果实时检测效果Web 界面运行效果：
命令行运行效果示例： 模型性能对比
检测示例结果分析与总结实验结果分析
遇到的问题与解决方案
改进方向
收获与体会通过本次实践，我深入理解了目标检测的完整流程，包括：
该项目展示了计算机视觉在实时场景中的应用价值，为后续更复杂的计算机视觉项目奠定了基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-14 分数：93.0/100 评语：报告结构完整，技术实现详实，实验结果展示充分，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
实践2：计算机视觉应用 编号：2501-21 项目目标与应用场景实验目标本次实验旨在构建一个基于深度学习的图像分类系统，实现对花卉（或类似物体）的自动识别与分类。具体目标包括：
应用场景本项目可应用于以下实际场景：
数据集与数据处理数据集来源本实验使用CIFAR-10数据集作为演示数据集，该数据集具有以下特点：
数据集特点分析
数据预处理方法1. 图像变换与增强train_transform = transforms.Compose([
transforms.Resize((224, 224)), # 统一尺寸
transforms.RandomHorizontalFlip(), # 水平翻转增强
transforms.RandomRotation(15), # 随机旋转
transforms.ColorJitter(), # 颜色抖动
transforms.ToTensor(), # 转张量
transforms.Normalize(...) # ImageNet标准化
])2. 数据增强策略
3. 数据集划分
模型或技术方案技术方案概述本项目采用迁移学习策略，基于预训练的EfficientNet-B0模型构建分类器。 模型架构EfficientNet-B0 主干网络分类头设计Classifier_Head:
├── Dropout(p=0.3)
├── Linear(1280, 512)
├── ReLU()
├── Dropout(p=0.2)
└── Linear(512, num_classes)选择原因
替代方案对比
实现与训练过程环境配置# 核心依赖
torch >= 2.0.0
torchvision >= 0.15.0
numpy >= 1.24.0
matplotlib >= 3.7.0
scikit-learn >= 1.3.0训练配置# 超参数设置
batch_size = 32
num_epochs = 20
learning_rate_backbone = 1e-4 # 骨干网络
learning_rate_head = 1e-3 # 分类头
weight_decay = 1e-4
scheduler = CosineAnnealingWarmRestarts训练策略1. 优化器选择
2. 学习率调度
3. 损失函数
训练流程关键代码实现模型定义class FlowerClassifier(nn.Module):
def __init__(self, num_classes=10):
super().__init__()
self.model = models.efficientnet_b0(
weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1
)
# 替换分类头
self.model.classifier = nn.Sequential(
nn.Dropout(0.3),
nn.Linear(1280, 512),
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(512, num_classes)
)训练循环for epoch in range(num_epochs):
model.train()
for images, labels in train_loader:
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()实验结果性能指标
训练曲线损失曲线分析
准确率曲线分析
混淆矩阵分析
预测样例展示正确预测样例（绿色标题）：
错误预测分析（红色标题）：
结果分析与总结成功经验
问题与改进方向
技术收获
未来展望
关键代码片段数据加载与预处理transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(15),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
dataset = datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)模型推理def predict(model, image_path):
model.eval()
image = Image.open(image_path).convert('RGB')
image_tensor = transform(image).unsqueeze(0)
with torch.no_grad():
output = model(image_tensor)
prob = torch.nn.functional.softmax(output[0], dim=0)
return prob.numpy()运行说明环境安装pip install torch torchvision numpy matplotlib scikit-learn运行训练python flower_classifier.py输出文件
实验完成日期：2026年6月11日 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-21 分数：95.0/100 评语：报告结构完整、内容详实，技术实现与分析深入，实验结果展示充分，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-24 实验2 计算机视觉应用——基于ResNet18的CIFAR-10图像分类实验时间：2026年6月11日 一、实验目标
二、数据集介绍与预处理2.1 数据集基本信息本实验使用CIFAR-10数据集，这是计算机视觉领域最经典的小型图像分类数据集之一，由加拿大高等研究院（CIFAR）发布。
2.2 数据预处理为了提高模型的泛化能力和训练稳定性，对数据集进行了以下预处理操作：
三、模型架构设计3.1 模型选择依据本实验选择ResNet18作为基础模型，原因如下：
3.2 ResNet18核心结构ResNet18由18个卷积层组成，包含4个残差块组，每个残差块包含2个卷积层和一个残差连接。整体架构如下：
3.3 模型修改针对CIFAR-10数据集的特点，对原始ResNet18进行了两处修改：
四、训练过程4.1 环境配置
4.2 超参数设置
4.3 训练步骤
4.4 核心训练代码import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.models import resnet18
from tqdm import tqdm
import matplotlib.pyplot as plt
# 数据预处理
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2, contrast=0.2),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
# 加载数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=4)
# 初始化模型
model = resnet18(pretrained=False)
# 修改初始卷积层
model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
# 移除最大池化层
model.maxpool = nn.Identity()
# 修改全连接层
model.fc = nn.Linear(512, 10)
model = model.cuda()
# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
# 训练和验证
best_acc = 0.0
train_losses = []
test_losses = []
train_accs = []
test_accs = []
for epoch in range(50):
# 训练阶段
model.train()
train_loss = 0.0
correct = 0
total = 0
pbar = tqdm(train_loader, desc=f'Epoch {epoch+1}/50')
for inputs, labels in pbar:
inputs, labels = inputs.cuda(), labels.cuda()
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
total += labels.size(0)
correct += predicted.eq(labels).sum().item()
pbar.set_postfix({'Loss': f'{train_loss/total:.4f}', 'Acc': f'{100.*correct/total:.2f}%'})
train_losses.append(train_loss/total)
train_accs.append(100.*correct/total)
# 验证阶段
model.eval()
test_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_loader:
inputs, labels = inputs.cuda(), labels.cuda()
outputs = model(inputs)
loss = criterion(outputs, labels)
test_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
total += labels.size(0)
correct += predicted.eq(labels).sum().item()
test_losses.append(test_loss/total)
test_accs.append(100.*correct/total)
print(f'Test Loss: {test_loss/total:.4f}, Test Acc: {100.*correct/total:.2f}%')
# 保存最佳模型
if 100.*correct/total > best_acc:
best_acc = 100.*correct/total
torch.save(model.state_dict(), 'best_model.pth')
print(f'Best model saved with accuracy: {best_acc:.2f}%')
scheduler.step()
print(f'Final best test accuracy: {best_acc:.2f}%')
# 绘制训练曲线
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(train_losses, label='Train Loss')
plt.plot(test_losses, label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Loss Curve')
plt.subplot(1, 2, 2)
plt.plot(train_accs, label='Train Accuracy')
plt.plot(test_accs, label='Test Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.legend()
plt.title('Accuracy Curve')
plt.tight_layout()
plt.savefig('training_curves.png')
plt.show()五、实验结果与分析5.1 训练过程曲线
5.2 混淆矩阵分析各类别准确率统计：
分析：
5.3 错误样本分析随机选取了10张模型分类错误的样本进行分析：
六、模型性能对比为了验证模型的有效性，将本实验的结果与其他经典模型在CIFAR-10数据集上的基准结果进行了对比：
分析：
七、实验总结与改进方向7.1 实验总结
7.2 改进方向
八、代码规范说明
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-24 分数：93.0/100 评语：报告结构完整、技术细节详实，代码实现规范且可复现，实验分析深入，充分体现了对ResNet18在CIFAR-10上应用的理解。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-03 作业：实践2 基于卷积神经网络（CNN）的猫狗图像分类 项目目标与应用场景 项目目标 本实验基于卷积神经网络（CNN）实现猫狗图像分类任务，训练模型自动识别输入图片属于“猫（Cat）”还是“狗（Dog）”。 通过本实验掌握：
计算机视觉应用场景 图像分类是计算机视觉领域最基础也是最重要的任务之一，广泛应用于： 智能安防
智能医疗
自动驾驶
智能零售
宠物识别
本实验以猫狗分类为例，体验完整的计算机视觉开发流程。 数据集与数据处理 数据集来源 实验采用 Kaggle Cats vs Dogs 数据集。 数据集来源： https://www.kaggle.com/c/dogs-vs-cats 数据集包含：
数据特点 图像类型 RGB彩色图像 图像尺寸 尺寸不统一 例如： 数据特点
具有较好的实际应用价值。 数据预处理方法 图像缩放 统一调整为： Resize((224,224))方便批量训练。 Tensor转换 ToTensor()将图片转换为Tensor格式。 数据标准化 Normalize(
mean=[0.485,0.456,0.406],
std=[0.229,0.224,0.225]
)作用：
数据增强 为了提高模型泛化能力： RandomHorizontalFlip()
RandomRotation(15)实现：
增加样本多样性。 模型或技术方案 模型架构 本实验采用经典CNN结构。 网络结构如下： 模型选择原因 CNN具有局部感知能力 能够提取：
参数共享 相比传统神经网络：
平移不变性 能够适应：
的猫狗图像。 自动特征学习 无需人工设计特征。 模型能够自动学习：
等关键特征。 实现与训练过程 数据加载 train_dataset = datasets.ImageFolder(
root="train",
transform=train_transform
)
train_loader = DataLoader(
train_dataset,
batch_size=32,
shuffle=True
)CNN模型定义 class CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Sequential(
nn.Conv2d(3,32,3,padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(32,64,3,padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64,128,3,padding=1),
nn.ReLU(),
nn.MaxPool2d(2)
)
self.fc = nn.Sequential(
nn.Linear(128*28*28,128),
nn.ReLU(),
nn.Linear(128,2)
)
def forward(self,x):
x=self.conv(x)
x=x.view(x.size(0),-1)
x=self.fc(x)
return x训练参数
模型训练 criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(
model.parameters(),
lr=0.001
)
for epoch in range(20):
model.train()
for images, labels in train_loader:
outputs = model(images)
loss = criterion(
outputs,
labels
)
optimizer.zero_grad()
loss.backward()
optimizer.step()实验结果 Loss变化
可以看到：
Accuracy变化
Accuracy曲线 测试集结果 模型能够准确识别绝大多数猫狗图像。 预测结果展示 运行输出示例 结果分析与总结 实验结果分析 从实验结果可以发现： CNN具有较强特征提取能力 卷积层能够自动提取：
等关键视觉信息。 数据增强效果明显 随机翻转与旋转提高了模型泛化能力。 测试集准确率提高约3%。 模型收敛稳定 训练过程中：
说明模型训练过程正常。 存在的问题 部分类别容易误判 例如：
容易出现分类错误。 数据集质量影响结果 部分图片：
会降低识别准确率。 改进方向 使用更深层网络 例如：
进一步提高分类精度。 增加数据增强 例如： ColorJitter()
RandomCrop()提高模型鲁棒性。 迁移学习 采用预训练模型： ResNet50
MobileNetV3
EfficientNet能够显著提高训练效率和准确率。 实验总结 本实验基于PyTorch实现了猫狗图像分类任务，完成了数据预处理、CNN模型构建、模型训练与测试等流程。 实验最终在测试集上取得95.1%的分类准确率，验证了卷积神经网络在图像分类任务中的有效性。 通过本实验，掌握了计算机视觉项目开发的基本流程，加深了对CNN网络结构、图像预处理及模型训练方法的理解，为后续目标检测、图像分割等更复杂视觉任务奠定了基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-03 分数：93.0/100 评语：报告结构完整，内容详实，技术理解准确，实验过程与结果展示清晰，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
实验设计报告编号：2501-25 实验目标
实验设计与过程1. 准备阶段
2. 启动服务cd "g:\研究生作业\智能花盆\ai-course-main\我自己学习资料\demos"
py -m http.server 8080浏览器访问：http://localhost:8080/05-neural-network-playground/ 或直接双击 3. 数据集MNIST 数据集：
ImageNet 数据集（用于 MobileNet）：
4. 模型架构4.1 MLP 手写数字识别模型网络结构：
选型理由：
4.2 MobileNet 图像分类模型核心结构：
本实验配置：
代码实现或技术说明1. 项目文件结构
2. 核心实现说明2.1 Canvas 绘制与图像预处理// 手写绘制：Canvas 绑定鼠标/触控事件
digitCanvas.addEventListener("mousedown", startDrawing);
digitCanvas.addEventListener("mousemove", drawDigit);预处理流程：
2.2 TensorFlow.js 模型加载// 加载 Keras 格式的 MLP 模型
mnistModel = await tf.loadLayersModel("models/digitrecognizermlp/model.json");
// 推理
const output = mnistModel.predict(prepared.tensor);
const probabilities = Array.from(await output.data());2.3 Softmax 概率输出模型原始输出是每个类别的 logit（未归一化），需要通过 Softmax 转换为概率分布： function softmax(scores) {
const max = Math.max(...scores);
const exp = scores.map((score) => Math.exp((score - max) * 7));
const sum = exp.reduce((total, item) => total + item, 0);
return exp.map((item) => item / sum);
}2.4 CNN 特征可视化MobileNet 的卷积层提取的特征包括：
3. 主要函数说明
实验结果1. 系统功能MLP 手写数字识别
CNN 图像分类
2. 性能测试
3. 识别准确率
4. 典型测试场景
分析与总结1. 模型局限性MLP 手写识别
MobileNet 图像分类
2. 技术亮点
3. 实验结论
4. 参考资料
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-25 分数：93.0/100 评语：报告结构完整，内容详实，技术实现与实验分析深入，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-27 基于卷积神经网络（CNN）的图像分类应用项目目标与应用场景实验目标本实验旨在利用卷积神经网络（Convolutional Neural Network，CNN）实现图像分类任务，通过对公开数据集进行训练和测试，掌握计算机视觉任务的基本流程，包括数据预处理、模型构建、模型训练、性能评估以及结果分析。 通过本实验，达到以下目标：
应用场景图像分类技术广泛应用于实际生活中，例如：
本实验以图像分类为例，模拟实际计算机视觉系统的工作过程。 数据集与数据处理数据集来源实验采用经典公开数据集 CIFAR-10。 数据集下载地址： https://www.cs.toronto.edu/~kriz/cifar.html 数据集由加拿大多伦多大学提供，共包含 60000 张彩色图片。 其中：
共包含 10 个类别：
图像大小均为： 属于 RGB 彩色图像。 数据特点CIFAR-10 数据集具有以下特点：
数据预处理为了提高模型训练效果，对数据进行了预处理。 （1）归一化将像素值由： 映射到： 减少数据波动，提高模型收敛速度。 （2）随机翻转增加训练样本多样性： transforms.RandomHorizontalFlip()（3）随机裁剪增强模型泛化能力： transforms.RandomCrop(32,padding=4)（4）标准化处理使数据均值接近 0： transforms.Normalize(
(0.5,0.5,0.5),
(0.5,0.5,0.5)
)完整预处理代码如下： import torchvision.transforms as transforms
transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32,padding=4),
transforms.ToTensor(),
transforms.Normalize((0.5,0.5,0.5),
(0.5,0.5,0.5))
])模型或技术方案卷积神经网络（CNN）实验采用经典 CNN 网络结构。 网络主要由：
组成。 整体结构如下： 模型选择原因选择 CNN 的原因如下： 1. 自动提取特征无需人工设计特征。 2. 参数共享减少参数数量，提高计算效率。 3. 局部感受野能够学习图像局部空间特征。 4. 适合图像分类任务CNN 在图像识别领域具有优秀性能。 因此，本实验选择 CNN 作为分类模型。 实现与训练过程实验环境
网络结构代码import torch
import torch.nn as nn
class CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Sequential(
nn.Conv2d(3,64,3,padding=1),
nn.ReLU(),
nn.Conv2d(64,64,3,padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
nn.Conv2d(64,128,3,padding=1),
nn.ReLU(),
nn.Conv2d(128,128,3,padding=1),
nn.ReLU(),
nn.MaxPool2d(2)
)
self.fc = nn.Sequential(
nn.Flatten(),
nn.Linear(128*8*8,256),
nn.ReLU(),
nn.Linear(256,10)
)
def forward(self,x):
x=self.conv(x)
x=self.fc(x)
return x损失函数采用交叉熵损失函数： criterion = nn.CrossEntropyLoss()计算公式： 优化器采用 Adam 优化算法： optimizer = torch.optim.Adam(
model.parameters(),
lr=0.001
)学习率： 训练参数
训练过程输出部分训练结果如下： 训练过程中模型逐渐收敛。 实验结果Loss变化曲线随着训练进行，Loss 持续下降。 Accuracy变化曲线准确率逐渐提高。 分类准确率
最终测试集准确率达到： 82.63%测试结果展示随机抽取测试样本进行预测：
预测结果整体较好。 示例： 结果分析与总结实验结果分析从训练结果可以看出： （1）Loss逐渐减小说明模型不断学习图像特征，训练过程稳定。 （2）准确率持续提高最终达到： 说明 CNN 能够较好地完成图像分类任务。 （3）存在误分类现象对于背景复杂或目标较小的图像，模型仍可能产生错误分类。 例如：
主要原因包括：
改进方向为了进一步提高识别精度，可以采用以下方法： 使用更深的网络例如：
增加数据增强包括：
引入正则化使用： Dropout
Weight Decay减少过拟合。 调整学习率采用： CosineAnnealingLR提高收敛效果。 增加训练轮数将 Epoch 提高到： 进一步提升模型性能。 总结本实验基于 PyTorch 构建了卷积神经网络图像分类模型，并在 CIFAR-10 数据集上完成训练和测试。 实验完成了：
最终测试准确率达到： 82.63%实验表明，卷积神经网络能够有效提取图像特征，在图像分类任务中具有较好的性能。 通过本次实验，进一步掌握了计算机视觉和深度学习的基本流程，为后续学习目标检测、图像分割以及 Transformer 视觉模型奠定了基础。 参考文献[1] Krizhevsky A. Learning Multiple Layers of Features from Tiny Images[J]. University of Toronto, 2009. [2] Goodfellow I, Bengio Y, Courville A. Deep Learning[M]. MIT Press, 2016. [3] Simonyan K, Zisserman A. Very Deep Convolutional Networks for Large-Scale Image Recognition[J]. arXiv:1409.1556, 2014. [4] He K, Zhang X, Ren S, et al. Deep Residual Learning for Image Recognition[C]. CVPR, 2016. [5] Paszke A, Gross S, Massa F, et al. PyTorch: An Imperative Style, High-Performance Deep Learning Library[J]. NeurIPS, 2019. |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-27 分数：93.0/100 评语：报告结构完整、内容详实，技术理解准确，实验过程与结果展示清晰，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-27 分数：93.0/100 评语：报告结构完整、内容详实，技术理解准确，实验过程与结果展示清晰，具备良好可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-07 一、项目目标与应用场景1.1 项目目标本项目主要完成一个计算机视觉图像分类应用。实验使用 CIFAR-10 图像数据集，通过构建卷积神经网络 CNN 模型，对图像进行自动分类识别。 CIFAR-10 数据集中包含 10 类常见物体图像，例如飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。通过本次实验，可以进一步理解计算机视觉中图像分类任务的基本流程。 本项目的主要目标如下：
1.2 应用场景图像分类是计算机视觉中最基础也最常见的任务之一，在实际生活中有广泛应用，例如：
本实验虽然使用的是 CIFAR-10 小型图像数据集，但整体流程与实际计算机视觉应用具有相似性，包括数据处理、模型构建、训练、评估和结果展示等步骤。 二、数据集与数据处理2.1 数据集介绍本实验使用 CIFAR-10 数据集。该数据集是计算机视觉领域常用的图像分类数据集，共包含 10 个类别。 数据集基本信息如下：
CIFAR-10 的类别包括： 中文类别对应如下：
2.2 数据预处理方法为了提高模型训练效果，本实验对图像数据进行了预处理。主要包括以下步骤：
关键代码如下： import torchvision.transforms as transforms
from torchvision import datasets
from torch.utils.data import DataLoader
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(
mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010)
)
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010)
)
])
train_dataset = datasets.CIFAR10(
root='./data',
train=True,
download=True,
transform=train_transform
)
test_dataset = datasets.CIFAR10(
root='./data',
train=False,
download=True,
transform=test_transform
)
train_loader = DataLoader(
train_dataset,
batch_size=64,
shuffle=True
)
test_loader = DataLoader(
test_dataset,
batch_size=100,
shuffle=False
)其中， 三、模型或技术方案3.1 技术方案本项目采用卷积神经网络 CNN 完成图像分类任务。CNN 在图像识别任务中应用广泛，能够自动提取图像中的空间特征，例如边缘、颜色、纹理和局部形状。 整体技术流程如下： 3.2 CNN 模型结构本实验设计了一个基础 CNN 模型，主要由卷积层、激活函数、池化层、Dropout 层和全连接层组成。 模型结构如下：
3.3 模型选择原因选择 CNN 作为本项目模型的原因如下：
四、实现与训练过程4.1 实验环境本实验使用 Python 和 PyTorch 完成。
4.2 模型代码import torch
import torch.nn as nn
import torch.nn.functional as F
class CNNModel(nn.Module):
def __init__(self):
super(CNNModel, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.dropout = nn.Dropout(0.5)
self.fc1 = nn.Linear(128 * 4 * 4, 256)
self.fc2 = nn.Linear(256, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = self.pool(F.relu(self.conv3(x)))
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = self.fc2(x)
return x4.3 损失函数与优化器本实验使用交叉熵损失函数 优化器使用 Adam 优化器，学习率设置为 0.001。 import torch.optim as optim
model = CNNModel().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)4.4 关键参数设置
4.5 训练过程代码epochs = 10
train_losses = []
train_accs = []
for epoch in range(epochs):
model.train()
running_loss = 0.0
correct = 0
total = 0
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
epoch_loss = running_loss / len(train_loader)
epoch_acc = 100 * correct / total
train_losses.append(epoch_loss)
train_accs.append(epoch_acc)
print(
f"Epoch [{epoch+1}/{epochs}], "
f"Loss: {epoch_loss:.4f}, "
f"Train Accuracy: {epoch_acc:.2f}%"
)训练过程中，每一轮都会计算当前 Epoch 的平均损失值和训练准确率。 4.6 测试过程代码model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_accuracy = 100 * correct / total
print(f"Test Accuracy: {test_accuracy:.2f}%")五、实验结果5.1 训练过程输出模型训练 10 个 Epoch 后，损失值整体下降，准确率逐渐提升。示例运行输出如下： 5.2 测试准确率模型在测试集上的准确率示例如下： 从测试结果可以看出，模型能够对 CIFAR-10 图像进行较好的分类识别。由于 CIFAR-10 图像类别较多，且图片内容比 MNIST 更复杂，因此准确率低于手写数字识别实验属于正常情况。 5.3 图表展示训练损失曲线import matplotlib.pyplot as plt
plt.plot(train_losses, marker='o')
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss Curve")
plt.grid(True)
plt.show()GitHub 中可以加入图片： 训练准确率曲线plt.plot(train_accs, marker='o')
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.title("Training Accuracy Curve")
plt.grid(True)
plt.show()GitHub 中可以加入图片： 5.4 预测结果展示部分图像预测结果示例如下： 其中，大部分图像能够被正确识别，但对于外形相似的类别，例如 cat 和 dog，模型仍然可能出现误判。 GitHub 中可以加入预测结果截图： 六、结果分析6.1 实验结果分析通过实验结果可以看出，CNN 模型能够完成 CIFAR-10 图像分类任务。随着训练轮数的增加，模型的 Loss 值逐渐下降，训练准确率逐渐上升，说明模型在不断学习图像中的有效特征。 本实验模型能够取得一定分类效果的原因主要有：
6.2 存在的问题虽然模型能够完成图像分类任务，但实验中仍然存在一些不足：
6.3 改进方向后续可以从以下几个方面进行优化：
七、完整代码import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision.transforms as transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
# 1. 设置运行设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 2. 数据预处理
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(
mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010)
)
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010)
)
])
# 3. 加载 CIFAR-10 数据集
train_dataset = datasets.CIFAR10(
root='./data',
train=True,
download=True,
transform=train_transform
)
test_dataset = datasets.CIFAR10(
root='./data',
train=False,
download=True,
transform=test_transform
)
train_loader = DataLoader(
train_dataset,
batch_size=64,
shuffle=True
)
test_loader = DataLoader(
test_dataset,
batch_size=100,
shuffle=False
)
# 4. 定义 CNN 模型
class CNNModel(nn.Module):
def __init__(self):
super(CNNModel, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.dropout = nn.Dropout(0.5)
self.fc1 = nn.Linear(128 * 4 * 4, 256)
self.fc2 = nn.Linear(256, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = self.pool(F.relu(self.conv3(x)))
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = self.fc2(x)
return x
# 5. 初始化模型、损失函数和优化器
model = CNNModel().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 6. 训练模型
epochs = 10
train_losses = []
train_accs = []
for epoch in range(epochs):
model.train()
running_loss = 0.0
correct = 0
total = 0
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
epoch_loss = running_loss / len(train_loader)
epoch_acc = 100 * correct / total
train_losses.append(epoch_loss)
train_accs.append(epoch_acc)
print(
f"Epoch [{epoch+1}/{epochs}], "
f"Loss: {epoch_loss:.4f}, "
f"Train Accuracy: {epoch_acc:.2f}%"
)
# 7. 测试模型
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_accuracy = 100 * correct / total
print(f"Test Accuracy: {test_accuracy:.2f}%")
# 8. 绘制 Loss 曲线
plt.plot(train_losses, marker='o')
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss Curve")
plt.grid(True)
plt.show()
# 9. 绘制 Accuracy 曲线
plt.plot(train_accs, marker='o')
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.title("Training Accuracy Curve")
plt.grid(True)
plt.show()八、运行输出示例运行输出如下： 九、项目文件结构十、实验总结本次实践完成了一个基于 CNN 的计算机视觉图像分类应用。实验以 CIFAR-10 数据集为基础，通过数据预处理、模型搭建、模型训练、测试评估和结果展示，完整实现了一个图像分类任务。 通过实验可以看出，CNN 在计算机视觉任务中具有较好的应用效果。卷积层能够提取图像中的局部特征，池化层能够降低特征维度，Dropout 可以减少过拟合，全连接层最终完成图像分类。 从实验结果来看，模型的损失值随着训练轮数增加逐渐下降，训练准确率逐渐提高，测试集准确率也达到了一定水平，说明模型能够学习到图像中的有效特征。 通过本次实验，我进一步理解了计算机视觉应用的基本流程，也掌握了使用 PyTorch 完成图像分类任务的方法。后续可以通过增加训练轮数、优化网络结构、使用更深层模型和增强数据处理方法进一步提高模型准确率。 十一、相关链接
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-07 分数：95.0/100 评语：报告结构完整、内容详实，技术理解深入，代码与实验过程清晰可复现，图表展示规范。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-23 计算机视觉（Computer Vision）是人工智能的重要研究方向，其核心任务是让计算机能够理解和分析图像信息。 图像分类是计算机视觉中的基础任务之一，其目标是根据图像内容自动识别其所属类别。 本实验以猫狗图像分类为例，利用卷积神经网络（CNN）构建图像分类模型，实现对输入图像的自动识别。 1.2 实验目标 采用 Kaggle Dogs vs Cats 数据集。 数据集包含： Cat（猫） 两个类别。 3.2 数据规模 为了提高模型泛化能力，对图像进行预处理。 4.1 图像缩放 统一尺寸： Resize((224,224)) 训练集采用： RandomHorizontalFlip() 作用： 增加样本多样性 采用经典卷积神经网络。 网络结构图 负责提取： 边缘 等图像特征。 池化层 降低特征图维度： 224×224→112×112 减少计算量。 Dropout 降低过拟合。 六、模型实现 class CNNModel(nn.Module): 6.2 损失函数 用于二分类任务。 6.3 优化器 八、实验结果 训练结果如下： Epoch Train Loss Loss decreases steadily during training. 0 Accuracy improves with training epochs. 70% 实验结果表明： CNN能够有效提取图像特征 最终测试准确率达到： 96.8% 主要出现在： 光照不足 特征不明显。 遮挡情况 导致误判。 特殊姿态 影响特征提取。 9.3 模型改进方向 采用： ResNet50 提升分类精度。 增加数据增强 提高泛化能力。 调整学习率策略 提升训练效果。 十、代码质量分析 相互独立。 可扩展性强 方便替换： 网络结构 符合PEP8规范： 命名清晰 本实验基于卷积神经网络实现了猫狗图像分类系统，完成了数据预处理、模型设计、训练与测试全过程。 实验结果表明： CNN能够有效学习图像特征； 通过本实验，进一步掌握了计算机视觉的基本流程和深度学习图像分类技术，为后续目标检测、图像分割等高级视觉任务奠定了基础。 附录：项目目录结构 CV-CatDog/ |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-23 分数：91.0/100 评语：报告结构完整，内容详实，技术实现清晰，实验结果展示充分，具备良好可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-15 一、实验目标 1.1 实验背景 交通标志检测是计算机视觉领域的重要应用之一，广泛应用于自动驾驶、智能交通系统（ITS）、车载辅助驾驶系统（ADAS）等场景。 随着深度学习的发展，基于卷积神经网络的目标检测算法在准确率和实时性方面取得了显著提升。其中YOLO（You Only Look Once）系列算法因其检测速度快、精度高，被广泛应用于实际工程项目。 本实验采用YOLOv8模型实现交通标志检测系统，对道路场景中的交通标志进行自动识别与定位。 1.2 实验目标
二、实验环境
三、数据集介绍 3.1 数据集来源 德国交通标志检测数据集（GTSDB） 数据集包含：
等多个类别交通标志。 3.2 数据规模
3.3 数据集划分 四、数据预处理 4.1 图像缩放 统一输入尺寸： 640×6404.2 数据增强 采用YOLOv8默认增强策略： Mosaic增强 随机拼接4张图片： 提高小目标检测能力。 随机翻转 Flip(p=0.5)色彩增强 随机调整：
增强模型泛化能力。 五、模型架构设计 5.1 YOLOv8整体结构 5.2 Backbone 采用C2f模块替代传统CSP模块。 特点：
5.3 Neck 采用： 结构实现多尺度特征融合。 5.4 Detection Head 预测：
输出格式： 六、代码实现 6.1 安装环境 pip install ultralytics6.2 数据集配置 path: datasets
train: train/images
val: val/images
names:
0: stop
1: speedlimit
2: noentry
3: yield
4: left
5: right6.3 模型训练 from ultralytics import YOLO
model = YOLO("yolov8n.pt")
model.train(
data="traffic.yaml",
epochs=100,
imgsz=640,
batch=16,
device=0
)6.4 模型验证 metrics = model.val()
print(metrics)6.5 图片检测 from ultralytics import YOLO
model = YOLO("runs/detect/train/weights/best.pt")
results = model.predict(
source="test.jpg",
save=True,
conf=0.25
)6.6 视频检测 model.predict(
source="traffic.mp4",
save=True
)七、训练过程 7.1 超参数设置
7.2 Loss变化 训练过程中：
说明模型正常收敛。 Loss数据
八、实验结果 8.1 模型评价指标 PrecisionRecallmAP目标检测主要评价指标： 8.2 实验结果
8.3 准确率变化趋势 8.4 Loss变化趋势8.5 检测效果展示测试样例1测试样例2测试样例3九、结果分析9.1 模型优点检测精度高mAP达到： 说明模型具有较好的检测能力。 检测速度快YOLOv8n推理速度： 满足实时检测需求。 泛化能力较强对于：
场景均具有较好表现。 9.2 存在问题小目标检测困难远距离交通标志容易漏检。 遮挡问题树叶、车辆遮挡时检测准确率下降。 夜间场景效果下降低照度环境下识别能力减弱。 十、实验总结本实验基于YOLOv8完成了交通标志检测系统设计与实现。 实验结果表明：
通过本实验掌握了：
十一、改进方向
参考文献[1] Redmon J, Farhadi A. YOLOv3: An Incremental Improvement. [2] Ultralytics YOLOv8 Documentation. [3] Bochkovskiy A. YOLOv4: Optimal Speed and Accuracy. [4] Goodfellow I. Deep Learning. [5] GTSDB Traffic Sign Detection Benchmark. |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-15 分数：93.0/100 评语：报告结构完整，内容详实，技术细节清晰，实验过程与结果展示充分。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-18 项目目标与应用场景实验目标本实验旨在利用深度学习中的卷积神经网络（CNN）实现猫狗图像分类任务。通过对图像数据进行训练，使模型能够自动识别输入图片属于猫还是狗，从而掌握计算机视觉领域中图像分类的基本流程和方法。 应用场景图像分类技术是计算机视觉的重要基础，其应用场景包括：
本实验通过猫狗分类任务模拟真实图像识别过程，为后续目标检测、图像分割等高级视觉任务奠定基础。 数据集与数据处理数据集来源本实验采用 Kaggle 提供的 Dogs vs Cats 数据集。 数据集包含：
图片格式均为 JPG。 数据特点
数据预处理为了提高训练效率，对数据进行了如下处理： 图像缩放统一调整为： (128,128)数据归一化image = image / 255.0将像素值映射到： [0,1]数据增强采用： ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range=0.2,
horizontal_flip=True
)增强模型泛化能力。 模型或技术方案模型选择本实验采用卷积神经网络（CNN）。 选择原因：
网络结构模型参数
实现与训练过程关键代码导入库import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout构建模型model = Sequential([
Conv2D(32,(3,3),activation='relu',
input_shape=(128,128,3)),
MaxPooling2D(2,2),
Conv2D(64,(3,3),activation='relu'),
MaxPooling2D(2,2),
Conv2D(128,(3,3),activation='relu'),
MaxPooling2D(2,2),
Flatten(),
Dense(128,activation='relu'),
Dropout(0.5),
Dense(1,activation='sigmoid')
])编译模型model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy']
)开始训练history = model.fit(
train_generator,
epochs=10,
validation_data=val_generator
)训练过程输出实验结果分类准确率
准确率变化趋势
测试结果示例
测试集中仅有少量图片被误分类。 成果展示实验成功实现：
模型能够较准确地区分猫和狗图像。 结果分析与总结实验结果分析从实验结果可以看出：
存在的问题
改进方向后续可以采用：
实验总结本实验完成了基于卷积神经网络的猫狗图像分类任务，掌握了计算机视觉项目从数据预处理、模型构建、训练到测试评估的完整流程。实验结果表明，CNN在图像分类任务中具有良好的性能，为后续学习目标检测、图像分割和深度学习视觉应用提供了实践基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-18 分数：93.0/100 评语：报告结构完整，内容详实，技术理解准确，实验过程与结果展示清晰，具备良好可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-09 项目目标与应用场景1.1 实验目标本实验旨在构建一个综合性的计算机视觉应用系统，包含以下核心目标：
1.2 应用场景本项目涉及的计算机视觉技术具有广泛的应用场景：
数据集与数据处理2.1 CIFAR-10数据集介绍CIFAR-10是一个常用的图像分类基准数据集，包含10个类别的60000张32x32彩色图像：
2.2 数据集特点
2.3 数据预处理方法# 数据加载
(x_train, y_train), (x_test, y_test) = datasets.cifar10.load_data()
# 归一化处理：将像素值从[0,255]缩放到[0,1]
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0
# 标签编码：转换为独热向量
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)2.4 实时检测数据集对于实时颜色检测，使用OpenCV捕获的摄像头视频流，无需预定义数据集。 模型或技术方案3.1 图像分类模型架构采用Advanced CNN架构，包含以下核心组件： 3.2 技术选择原因3.2.1 深度卷积神经网络相比传统机器学习方法，CNN能够自动学习图像的层次化特征表示：
3.2.2 Batch Normalization（批归一化）
3.2.3 Dropout正则化
3.2.4 学习率调整策略使用ReduceLROnPlateau回调函数：
3.3 颜色检测技术方案采用HSV颜色空间的阈值分割方法： color_ranges = {
'Red': ((0, 100, 100), (10, 255, 255)),
'Green': ((35, 50, 50), (85, 255, 255)),
'Blue': ((90, 50, 50), (130, 255, 255)),
'Yellow': ((20, 100, 100), (30, 255, 255)),
'Orange': ((10, 100, 100), (20, 255, 255)),
'Purple': ((130, 50, 50), (170, 255, 255))
}HSV空间优势：
实现与训练过程4.1 开发环境配置# 所需库
pip install tensorflow matplotlib numpy opencv-python pillow4.2 训练过程详解4.2.1 模型编译model.compile(
optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
loss='categorical_crossentropy',
metrics=['accuracy']
)
4.2.2 训练配置history = model.fit(
x_train, y_train,
epochs=20,
batch_size=64,
validation_split=0.1,
callbacks=[reduce_lr],
verbose=1
)
4.2.3 训练过程记录
4.3 实时颜色检测实现def detect_color(frame, color_name, lower_bound, upper_bound):
# 转换到HSV空间
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# 创建掩码
mask = cv2.inRange(hsv, np.array(lower_bound), np.array(upper_bound))
# 查找轮廓
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 标注检测到的目标
if contours:
largest_contour = max(contours, key=cv2.contourArea)
if cv2.contourArea(largest_contour) > 500:
x, y, w, h = cv2.boundingRect(largest_contour)
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
return True
return False实验结果5.1 CIFAR-10分类结果5.1.1 最终性能指标
5.1.2 分类混淆矩阵5.2 训练曲线
5.3 分类结果可视化
5.4 颜色检测结果
5.5 图像增强结果
5.6 关键代码文件
结果分析与总结6.1 实验结果分析6.1.1 模型性能分析
6.1.2 颜色检测效果
6.2 技术难点与解决方案6.2.1 CIFAR-10挑战难点：相比MNIST，CIFAR-10图像更小（32×32），但类别内差异更大 解决方案：
6.2.2 颜色检测挑战难点：光照变化影响颜色感知 解决方案：
6.3 改进方向
6.4 实验总结本次实验成功完成了一个综合性的计算机视觉应用系统：
该系统展示了计算机视觉在实际应用中的多样性和实用性，为进一步研究和应用奠定了基础。 6.5 技术收获通过本次实验，深入理解了：
这些知识和技能为未来从事计算机视觉相关工作打下了坚实基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-09 分数：95.0/100 评语：报告结构完整、内容详实，技术实现与分析深入，实验结果展示充分，具备良好可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2502-20 项目目标与应用场景1.1 项目目标本次计算机视觉应用项目旨在构建一个完整的手写数字识别系统，主要目标包括： 深度学习模型构建：设计并实现基于卷积神经网络（CNN）的高性能手写数字识别模型 1.2 应用场景手写数字识别技术具有广泛的实际应用价值： 教育领域： 金融领域： 邮政快递： 办公自动化： 医疗健康： 数据集与数据处理2.1 数据集介绍本项目使用经典的MNIST数据集（Modified National Institute of Standards and Technology database），这是计算机视觉和深度学习领域最著名、最常用的基准数据集之一。 数据集特点： 数据集优势： 2.2 数据预处理数据预处理是计算机视觉应用的关键环节，本项目实现了多层次的预处理流程： 2.2.1 基础预处理# 像素值归一化
x_train = x_train.astype('float32') / 255.0 # [0, 255] → [0, 1]
x_test = x_test.astype('float32') / 255.0
# 添加通道维度
x_train = np.expand_dims(x_train, -1) # (28, 28) → (28, 28, 1)
x_test = np.expand_dims(x_test, -1)归一化作用： 2.2.2 标签编码# One-Hot编码
y_train = to_categorical(y_train, 10) # [7] → [0,0,0,0,0,0,0,1,0,0]
y_test = to_categorical(y_test, 10)编码优势： 2.2.3 数据集划分训练集：54,000张（90%）用于模型学习 2.3 实时识别预处理针对摄像头输入和手写输入，实现了专门的图像预处理流程： def preprocess_digit(img):
# 灰度化处理
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 高斯模糊去噪
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
# 自适应阈值二值化
binary = cv2.adaptiveThreshold(blurred, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY_INV, 11, 2)
# 形态学操作
kernel = np.ones((3, 3), np.uint8)
binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
# 数字区域提取
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# 尺寸归一化到28×28
resized = cv2.resize(digit, (28, 28), interpolation=cv2.INTER_AREA)预处理技术说明： 模型或技术方案3.1 技术方案总览本项目采用基于深度学习的计算机视觉技术方案，核心技术包括： **深度学习框架：**TensorFlow 2.x / Keras 主要技术栈： 3.2 CNN模型架构3.2.1 网络结构设计3.2.2 各层详解卷积层（Convolutional Layer）： 批量归一化层（Batch Normalization）： 池化层（Max Pooling Layer）： Dropout层： 全连接层（Dense Layer）： 3.3 技术选型理由选择CNN的原因： 选择双卷积块的原因： 选择Batch Normalization的原因： 实现与训练过程4.1 开发环境软件环境： 硬件要求： 4.2 训练配置4.2.1 优化器配置optimizer='adam'Adam优化器优势： 4.2.2 损失函数loss='categorical_crossentropy'交叉熵损失特点： 4.2.3 训练参数
4.3 训练策略4.3.1 学习率衰减ReduceLROnPlateau(
monitor='val_loss',
factor=0.5,
patience=3,
verbose=1
)触发机制： 4.3.2 早停法EarlyStopping(
monitor='val_loss',
patience=5,
restore_best_weights=True,
verbose=1
)保护机制： 4.4 训练过程监控快速收敛期（Epoch 1-5）： 稳定优化期（Epoch 6-10）： 早停触发（Epoch 11+）： 4.5 模型保存与加载# 保存模型
model.save('cv_digit_model.h5')
# 加载模型
model = tf.keras.models.load_model('cv_digit_model.h5')保存格式：HDF5，支持完整模型序列化 实验结果5.1 整体性能指标
5.2 训练曲线分析准确率曲线： 损失曲线： 5.3 各类别识别性能
5.4 混淆矩阵分析高识别率类别（>99.5%）： 易混淆类别： 识别困难原因： 5.5 可视化成果5.5.1 训练曲线图（此处应包含training_curves.png图像） 5.5.2 预测样本展示（此处应包含prediction_samples.png图像） 5.5.3 混淆矩阵热力图（此处应包含confusion_matrix.png图像） 5.5.4 类别准确率柱状图（此处应包含class_accuracies.png图像） 结果分析与总结6.1 模型性能分析6.1.1 高准确率原因本模型在MNIST数据集上达到99.21%的测试准确率，主要原因包括： 网络架构合理： 正则化技术有效： 训练策略得当： 预处理完善： 6.1.2 误差来源分析尽管准确率很高，但仍存在约0.8%的错误，主要来源： 书写变化问题： 图像质量问题： 相似数字混淆： 6.2 技术收获通过本次计算机视觉应用项目，我深入学习和实践了： 深度学习技术： 计算机视觉处理： 实战开发能力： 问题解决能力： 6.3 应用价值技术价值： 实用价值： 教学价值： 6.4 改进方向6.4.1 数据层面改进数据增强： 数据扩充： 6.4.2 模型层面改进网络架构优化： 训练策略优化： 6.4.3 应用层面改进实时识别优化： 交互体验优化： 6.5 项目总结本次计算机视觉应用项目圆满完成，主要成果： ✅ 模型性能优异：测试准确率达99.21%，超过人类平均水平（96%） 关键创新点： 展望： 附录A. 完整代码主程序文件：cv_digit_recognition.py B. 环境依赖C. 生成文件列表
D. 运行说明安装依赖： E. 参考资料LeCun, Y., et al. (1998). "Gradient-based learning applied to document recognition" 报告生成时间：2026年6月11日 格式说明
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2502-20 分数：97.0/100 评语：报告内容完整、结构清晰，技术实现详实，实验结果展示充分，具备高度可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-02 计算机视觉应用实验报告：基于 CNN/ResNet 的 CIFAR-10 图像分类
一、实验目标本实验选择“自然图像分类”作为计算机视觉应用场景，使用深度卷积神经网络对 CIFAR-10 数据集中的图像进行分类识别。实验目标如下：
二、数据集介绍本实验使用 CIFAR-10 数据集。CIFAR-10 是计算机视觉领域常用的图像分类数据集，包含 10 个类别的彩色自然图像。
与 MNIST 手写数字相比，CIFAR-10 图像背景更复杂，类别间差异更细，适合用于展示计算机视觉模型对颜色、纹理、边缘和语义特征的提取能力。 三、数据预处理方法为了提高模型泛化能力，实验对训练集进行数据增强，对测试集只进行标准化处理，确保测试结果稳定。
标准化参数采用 CIFAR-10 常用设置： mean = (0.4914, 0.4822, 0.4465)
std = (0.2470, 0.2435, 0.2616)数据预处理代码示例： transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2470, 0.2435, 0.2616))
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2470, 0.2435, 0.2616))
])四、模型架构本实验采用适配 CIFAR-10 小尺寸图像的 ResNet-18 模型。原始 ResNet-18 通常用于较大尺寸图像，因此实验中对第一层卷积和池化结构进行了调整：
模型构建代码示例： import torch.nn as nn
from torchvision import models
def build_model(num_classes=10):
model = models.resnet18(weights=None)
model.conv1 = nn.Conv2d(
3, 64, kernel_size=3, stride=1, padding=1, bias=False
)
model.maxpool = nn.Identity()
model.fc = nn.Linear(model.fc.in_features, num_classes)
return model五、训练过程训练过程使用交叉熵损失函数和 Adam 优化器。每个 epoch 完成后，在测试集上计算损失和准确率，并保存实验结果。
训练流程如下：
训练核心代码示例： def train_one_epoch(model, loader, criterion, optimizer, device):
model.train()
total_loss, correct, total = 0.0, 0, 0
for images, labels in loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item()
correct += (outputs.argmax(1) == labels).sum().item()
total += labels.size(0)
return total_loss / len(loader), correct / total六、代码实现与代码质量本实验代码实现时建议采用模块化结构，便于维护和复现实验：
代码质量评价：
七、实验结果展示下表为 10 轮训练的实验结果示例。可以看到，随着训练轮数增加，训练损失逐步下降，测试准确率持续提升。
图1 训练损失与测试准确率变化曲线 从图1可以看出，训练损失整体呈下降趋势，说明模型参数逐渐优化；测试准确率不断提高，说明模型在测试集上的泛化能力逐步增强。
图2 CIFAR-10 各类别测试准确率 从图2可以看出， 八、模型准确度分析本实验最终测试准确率约为 86.8%。对于 CIFAR-10 这类自然图像分类任务，该结果说明模型已经学习到了较有效的图像特征。
九、结果分析实验结果表明，深度卷积神经网络能够有效完成多类别自然图像分类任务。ResNet 的残差连接有助于训练更深层网络，使模型能够学习从边缘、纹理到语义类别的多层特征。 训练初期，模型对图像类别的区分能力较弱，因此准确率较低；随着训练进行，卷积层逐渐学习到类别相关特征，准确率明显提升。后期准确率提升速度变慢，说明模型逐渐接近当前结构和训练参数下的性能上限。 错误分类主要集中在视觉特征相似的类别。例如，猫和狗都属于动物类别，姿态、颜色和背景变化较大；鸟和鹿等类别在低分辨率图像中细节有限，也可能导致分类困难。 十、实验结论本实验完成了一个完整的计算机视觉图像分类应用。通过 CIFAR-10 数据集、数据增强、改进 ResNet-18 模型和规范训练流程，模型能够对 10 类自然图像进行较准确识别，最终测试准确率约为 86.8%。 实验说明：
十一、改进方向后续可以从以下方面继续优化：
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-02 分数：93.0/100 评语：报告结构完整、内容详实，技术实现清晰，实验结果展示充分，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-24 项目目标与应用场景本次实践2的项目主题是“基于 OpenCV 的交通信号灯颜色识别”。该任务属于计算机视觉中的目标检测与颜色分类应用，主要目标是让程序从图像中找到交通信号灯的发光区域，并判断当前信号灯状态属于红灯、黄灯还是绿灯。 交通信号灯识别可以应用在智能交通、自动驾驶辅助、道路监控和机器人视觉导航等场景中。对于自动驾驶系统来说，车辆不仅需要检测道路上的物体，还需要理解交通信号灯的颜色状态，从而辅助完成停车、减速或通行决策。本实验没有使用大型深度学习模型，而是采用 OpenCV 中常见的 HSV 色彩空间转换、阈值分割和轮廓检测方法完成一个轻量级视觉识别流程。 本项目的整体流程为：生成模拟交通灯图像数据集 → 进行图像预处理 → 提取高饱和度和高亮度区域 → 寻找最大轮廓 → 根据 HSV 色相值判断颜色类别 → 输出识别结果和准确率。 数据集与数据处理本实验使用 Python 和 OpenCV 构建了一个小型模拟数据集。数据集共包含 240 张交通信号灯图像，每张图像尺寸为 160×160 像素，分为红灯、黄灯、绿灯 3 个类别，每个类别 80 张。 数据集的特点如下：
数据预处理主要包括以下步骤：
选择 HSV 空间的原因是，RGB 三个通道容易受到亮度变化影响，而 HSV 中的 H 通道更能表示颜色类型，S 和 V 通道可以辅助排除背景区域，因此更适合完成交通灯颜色识别。 模型或技术方案本实验采用传统计算机视觉方法，不使用复杂神经网络。核心技术方案为“HSV 阈值分割 + 轮廓检测 + 色相规则分类”。 技术流程如下： 分类规则如下： 这种方案的优点是实现简单、运行速度快、对小型任务比较稳定，而且不需要大量训练数据。缺点是对复杂真实场景适应性有限，例如强反光、阴影、夜间曝光异常、信号灯被遮挡等情况可能会导致识别错误。 实现与训练过程本项目主要是基于规则的视觉识别流程，因此没有进行深度学习训练，而是通过一组样例图像进行参数调试。最终使用的关键参数为：饱和度阈值 S > 75，亮度阈值 V > 85，最小轮廓面积为 40。 核心代码如下： import cv2
import numpy as np
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
labels = ['red', 'yellow', 'green']
def classify_light(img):
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
mask = ((hsv[:, :, 1] > 75) & (hsv[:, :, 2] > 85)).astype(np.uint8) * 255
mask = cv2.medianBlur(mask, 5)
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if not contours:
return 'unknown'
cnt = max(contours, key=cv2.contourArea)
if cv2.contourArea(cnt) < 40:
return 'unknown'
obj_mask = np.zeros(mask.shape, dtype=np.uint8)
cv2.drawContours(obj_mask, [cnt], -1, 255, -1)
hue_values = hsv[:, :, 0][obj_mask > 0]
h = float(np.median(hue_values))
if h < 10 or h > 170:
return 'red'
elif 16 <= h <= 42:
return 'yellow'
elif 43 <= h <= 95:
return 'green'
else:
return 'unknown'运行过程可以概括为：先批量生成 240 张模拟图像，然后逐张输入 实验结果本次实验共测试 240 张图像，其中 236 张识别正确，整体准确率为 98.33%。运行输出如下： 分类报告如下： 从混淆矩阵可以看出，红灯样本 80 张全部识别正确，绿灯样本中有 1 张被识别为黄灯，黄灯样本中有 3 张因为颜色偏移和亮度不足被判断为 unknown。整体来看，该方法在模拟交通灯识别场景中具有较好的效果。 图表展示说明：Word 留存版中已插入样例识别图和混淆矩阵图。GitHub 文字版中使用上述运行输出和矩阵文本代替截图展示。 结果分析与总结从实验结果来看，基于 HSV 阈值和轮廓检测的传统计算机视觉方法能够较好地完成交通信号灯颜色识别任务。该方法不需要训练大型模型，代码量较少，运行速度快，适合用于背景较简单、颜色区分明显的应用场景。 本实验能够取得较高准确率，主要原因有三点。第一，交通灯颜色本身具有较明显的色相差异，红、黄、绿在 HSV 空间中比较容易区分。第二，实验通过饱和度和亮度阈值过滤掉了大部分背景区域，减少了非目标像素的干扰。第三，使用最大轮廓作为发光区域，可以避免少量噪声点直接影响分类结果。 不过，本实验也存在一定局限。首先，数据集是模拟生成的，真实道路图像中会出现更多复杂情况，例如灯光反射、雨雾天气、背景广告牌、摄像头角度变化等。其次，固定阈值方法对光照条件比较敏感，如果夜间曝光过强或白天阳光反射明显，可能出现误检或漏检。再次，本实验只判断颜色，没有进一步检测交通灯在图像中的真实位置和距离。 针对这些问题，后续可以从以下方向改进：一是收集真实道路交通灯图像，建立更接近实际应用的数据集；二是引入自适应阈值或颜色校正方法，提高对不同光照条件的适应能力；三是结合 YOLO、SSD 等目标检测模型先定位交通灯区域，再进行颜色识别；四是将连续视频帧的结果进行平滑处理，避免单帧误判影响最终结果。 总体而言，本次实践完成了一个较完整的计算机视觉应用流程，包括应用场景设计、数据构建、图像预处理、技术方案实现、结果评估和误差分析。通过本实验，我理解了 HSV 色彩空间、图像阈值分割、轮廓检测等传统视觉方法在实际任务中的作用，也认识到传统方法虽然简单高效，但在复杂场景下仍需要和深度学习检测模型结合，才能获得更强的泛化能力。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-24 分数：97.0/100 评语：报告结构完整、内容详实，技术实现清晰，实验结果展示充分，分析深入且具有前瞻性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-17 分数：0.0/100 评语：提交内容仅为一个空的 Word 文件链接，无实际报告内容，未包含任何实验目标、数据处理、模型实现或结果分析。 建议：
AI 复制风险：high。提交内容为纯文件链接，无实质性文本内容，无法判断是否由 AI 辅助生成，但存在明显规避评审要求的行为，风险极高。 说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-17
1.2 整体设计逻辑
二、数据集与预处理2.1 数据集简介 2.2 数据预处理与增强策略
2.3 数据加载代码实现 import torch
import torchvision
import torchvision.transforms as transforms
# 训练集预处理（含增强）
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32, padding=4),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
# 测试集预处理（仅标准化）
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
# 加载数据集（自动下载）
train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=test_transform)
# 创建 DataLoader（批量加载，打乱顺序）
train_loader = torch.utils.data.DataLoader(train_set, batch_size=128, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=100, shuffle=False, num_workers=2)三、CNN 网络结构设计 网络层次表：
为何如此设计？ 核心代码： import torch.nn as nn
class CustomCNN(nn.Module):
def __init__(self):
super(CustomCNN, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, kernel_size=3, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
nn.Conv2d(128, 256, kernel_size=3, padding=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
)
self.classifier = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(256 * 4 * 4, 512),
nn.ReLU(inplace=True),
nn.Linear(512, 10)
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x3.2 方案 B：迁移学习（预训练 ResNet18） 网络结构改造：
选择原因： 核心代码： import torchvision.models as models
def get_resnet18():
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
# 冻结所有卷积层参数
for param in model.parameters():
param.requires_grad = False
# 替换分类层（新层默认 requires_grad=True）
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)
return model四、训练过程与关键参数
设计思路：迁移学习因参数初始化优秀，采用 SGD 配合动量能获得更锐利的极小值；自定义 CNN 使用 Adam 自适应学习率以快速逃离初始较差的状态。 4.2 训练循环通用代码 import torch.optim as optim
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def train_model(model, train_loader, test_loader, criterion, optimizer, scheduler, epochs, model_name="Model"):
model.to(device)
best_acc = 0.0
print(f"--Training {model_name} ---")
for epoch in range(epochs):
# ---------训练阶段 ----------
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()
# 更新学习率
scheduler.step()
# ---------测试阶段 ----------
model.eval()
correct, total, test_loss = 0, 0, 0.0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
test_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
avg_train_loss = running_loss / len(train_loader)
avg_test_loss = test_loss / len(test_loader)
accuracy = 100 * correct / total
print(f'Epoch {epoch+1:2d}/{epochs} | Train Loss: {avg_train_loss:.4f} | Test Loss: {avg_test_loss:.4f} | Acc: {accuracy:.2f}%')
if accuracy > best_acc:
best_acc = accuracy
torch.save(model.state_dict(), f'best_{model_name}.pth')
print(f"Best Test Accuracy for {model_name}: {best_acc:.2f}%")
return best_acc4.3 遇到的主要问题与解决方案 五、实验结果 5.1 性能指标对比
5.2 训练过程详细记录（节选关键轮次） 方案 A（自定义 CNN）训练日志：
方案 B（ResNet18）训练日志：
5.3 运行终端输出截图（文字模拟） 六、结果分析与总结
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-17 分数：95.0/100 评语：报告结构完整、技术细节深入，实验设计逻辑清晰，结果分析充分且具有洞察力。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 分数：0.0/100 评语：提交内容仅为一张图片链接，无实质性报告内容，未按要求填写完整结构与实验细节，不符合有效提交标准。 建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-11作业：实践2 基于 Grounding DINO 的开放词汇目标检测应用实践一、项目目标与应用场景本次实践选择的复现论文是《Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection》。这篇论文主要研究开放词汇目标检测，也就是模型不再只能检测固定类别，而是可以根据用户输入的文字提示，在图片中找到对应的目标。 传统目标检测模型通常只能识别训练集中出现过的类别，比如 COCO 数据集中的人、车、猫、狗等固定类别。如果想检测新的类别，往往需要重新标注数据并训练模型。Grounding DINO 的不同之处在于，它可以把文本和图像结合起来。用户输入“person”“car”“red bag”等文字提示后，模型就可以在图像中定位相关目标。 我认为这个方向很适合实际应用。例如在校园场景中，可以用它检测行人、车辆、自行车、路牌等目标；在安防场景中，可以根据文字描述快速查找特定物体；在图像标注任务中，也可以用它辅助生成目标检测框，减少人工标注成本。因此，本次实践的目标是了解 Grounding DINO 的基本原理，并使用预训练模型完成一次简单的开放词汇目标检测实验。 二、数据集与数据处理本次实践没有从零训练大模型，而是使用 Grounding DINO 提供的预训练模型进行推理测试。原因是 Grounding DINO 这类视觉语言模型参数量较大，训练需要大量数据和较高算力，普通课程实践更适合从应用角度进行理解和验证。 实验数据可以选择两类图片。一类是公开图片，例如 COCO 数据集中的街景、动物、人物、交通工具等图片；另一类是自己收集的生活场景图片，例如校园道路、教室、宿舍桌面、停车区域等。为了方便测试模型的开放词汇能力，可以选择目标类别比较丰富的图片，例如包含人、车、书包、电脑、桌椅等物体的场景。 在数据处理方面，主要包括以下步骤：首先准备待检测图片，将图片统一保存到指定文件夹；然后根据图片内容设置文本提示词，例如“person . car . bicycle . backpack . laptop”；最后将图片和文本提示同时输入模型，得到检测框、类别文本匹配结果和置信度分数。 三、模型或技术方案Grounding DINO 的核心思想是把目标检测和语言理解结合起来。普通目标检测模型通常是输入图片，然后输出固定类别的检测框；而 Grounding DINO 是同时输入图片和文本提示，让模型根据文本内容去寻找图片中对应的目标。 这种方法的优势在于灵活性更强。比如普通检测模型可能只能检测“dog”这个类别，而 Grounding DINO 不仅可以检测“dog”，还可以根据描述检测“the dog on the left”或者“a black bag on the table”这样的目标。这说明它不只是做简单分类，而是能够把语言描述和图像区域对应起来。 四、实现与运行过程本次实践计划使用官方开源代码和预训练权重完成实验。整体流程如下： 第一步，下载 Grounding DINO 官方代码，并配置 Python、PyTorch 等运行环境。第二步，下载官方提供的预训练模型权重。第三步，准备若干张测试图片，例如街景图片、校园图片或室内场景图片。第四步，设置文本提示词，例如“person . car . bicycle . backpack . chair . laptop”。第五步，运行推理代码，得到检测结果。第六步，保存可视化图片，观察模型是否能正确框出目标。 关键代码流程可以概括为：读取图片，加载 Grounding DINO 模型，输入文本提示词，设置 box threshold 和 text threshold，运行模型推理，最后把检测框绘制到原图上。 下面给出本次实验的核心推理代码。运行前需要将配置文件、模型权重和测试图片路径替换为本机的实际路径： 其中， 在实验过程中，阈值设置会影响检测结果。如果阈值过低，模型可能会检测出较多错误目标；如果阈值过高，一些不太明显的目标可能会被漏检。因此，需要根据图片内容适当调整阈值。 图1 校园道路场景检测结果。文本提示包含 person、bicycle、car、backpack 和 tree，置信阈值设为 0.30。该阈值能够保留远处行人和车辆等相对较弱的目标，同时准确框出近处人物、自行车和背包；但树木等范围较大的目标框可能出现一定重叠。若继续提高阈值，误检和重复框会减少，但远处置信度约为 0.58～0.62 的行人也更容易被漏检。 图2 室内学习场景零样本检测结果。模型能够识别人、椅子、桌子、笔记本电脑、书本、白板、水瓶、笔记本和笔等多种目标，主要目标的置信度集中在 0.90 以上。采用 图3 不同 五、实验结果从实验结果来看，Grounding DINO 对常见目标具有较好的检测能力。例如在街景图片中，输入“person . car . bicycle”后，模型能够较准确地检测出行人、汽车和自行车等目标。在室内场景中，输入“laptop . chair . table . book”后，模型也可以识别出桌子、椅子、电脑等物体。 和普通目标检测模型相比，Grounding DINO 的一个明显优点是使用方式更加灵活。用户不需要修改模型结构，也不需要重新训练，只需要改变文本提示词，就可以检测不同类别的物体。这一点体现了开放词汇目标检测的优势。 不过实验中也会发现一些问题。首先，当图片中目标较小、被遮挡或者背景比较复杂时，模型可能会漏检。其次，如果文本提示词写得不够清楚，模型可能会出现误检。例如输入比较宽泛的词时，模型可能会把相似物体也检测出来。另外，Grounding DINO 本身主要输出目标检测框，如果想得到更精细的目标轮廓，还需要结合 Segment Anything 等分割模型进一步处理。 六、结果分析与总结通过本次实践，我对开放词汇目标检测有了更直观的理解。传统目标检测更像是在固定类别范围内做识别，而 Grounding DINO 则通过引入语言信息，让模型能够根据用户输入的文本去寻找目标。这种方式提高了模型的泛化能力，也让计算机视觉系统更接近真实应用需求。 从应用角度看，Grounding DINO 可以用于智能安防、自动驾驶辅助、图像检索、数据标注、遥感图像分析等场景。尤其是在数据标注成本较高的任务中，它可以作为辅助工具，先自动生成检测框，再由人工进行检查和修改，从而提高数据处理效率。 本次实践的不足是没有进行完整训练，只是基于预训练模型进行了推理测试。因此，对模型训练过程、损失函数设计和大规模数据预训练的理解还不够深入。后续如果有条件，可以进一步尝试用自己的小规模数据集进行微调，或者将 Grounding DINO 和 SAM 结合，实现“文本提示目标检测 + 精细分割”的完整视觉应用流程。 总体来看，Grounding DINO 是一篇具有代表性的计算机视觉顶会论文。它把目标检测和自然语言理解结合起来，使模型能够根据文本提示完成开放场景下的目标定位。通过这次实践，我不仅了解了开放词汇目标检测的基本思想，也认识到当前计算机视觉正在从固定类别识别逐渐向多模态、开放世界和通用视觉模型方向发展。 七、参考资料[1] Liu, S., Zeng, Z., Ren, T., Li, F., Zhang, H., et al. Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection. ECCV 2024. |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-11 分数：93.0/100 评语：报告结构完整，内容详实，技术理解深入，实验过程清晰，结果分析有见地。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 分数：93.0/100 评语：报告结构完整，内容详实，技术理解深入，实验过程与结果展示充分，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-01 分数：93.0/100 评语：报告结构完整、内容详实，技术理解深入，实验过程与结果展示清晰，具备良好的可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-01 分数：95.0/100 评语：报告内容完整、结构清晰，技术实现详实，实验分析深入，具备高度可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
编号: 2501-06作业: 实践2## 项目目标与应用场景1. 实验目标
2. 计算机视觉应用场景本次实验采用CIFAR-10通用物体数据集，对应落地场景覆盖多类计算机视觉业务：
## 数据集与数据处理1. 数据集来源与特点数据集选用CIFAR-10，计算机视觉经典小型通用物体数据集：
2. 完整预处理方法分为训练集增强流水线、测试集标准化流水线两部分，区分设计避免测试集引入随机扰动： （1）训练集预处理（含数据增强，抑制过拟合核心手段）from torchvision import transforms
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4), # 随机裁剪+四周填充，模拟物体偏移
transforms.RandomHorizontalFlip(p=0.5), # 50%概率水平翻转，扩充样本多样性
transforms.ToTensor(),
# CIFAR10官方均值方差标准化
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])（2）测试集预处理（仅标准化，无随机变换）test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])（3）数据集加载代码from torchvision import datasets
from torch.utils.data import DataLoader
train_dataset = datasets.CIFAR10(root="./cifar10", train=True, download=True, transform=train_transform)
test_dataset = datasets.CIFAR10(root="./cifar10", train=False, download=True, transform=test_transform)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=2)3. 预处理设计说明
## 模型或技术方案1. 模型架构：ResNet18轻量化残差网络网络整体结构
核心残差单元代码实现import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_channels, out_channels, stride=1):
super().__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
# 短路连接维度匹配分支
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels * self.expansion:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, out_channels*self.expansion, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels*self.expansion)
)
def forward(self, x):
residual = self.shortcut(x)
out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += residual # 残差连接核心
out = F.relu(out)
return out2. 选择ResNet18的原因
## 实现与训练过程1. 完整训练核心代码# 设备自动适配
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ResNet18(BasicBlock, [2,2,2,2]).to(device)
# 损失函数与优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
# 学习率调度：每20轮衰减为原来0.1倍
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)
epochs = 50
train_loss_log = []
test_acc_log = []
for epoch in range(epochs):
# 训练阶段
model.train()
total_loss = 0.0
for data, label in train_loader:
data, label = data.to(device), label.to(device)
optimizer.zero_grad()
pred = model(data)
loss = criterion(pred, label)
loss.backward()
optimizer.step()
total_loss += loss.item() * data.size(0)
avg_train_loss = total_loss / len(train_dataset)
train_loss_log.append(avg_train_loss)
# 验证阶段
model.eval()
correct = 0
with torch.no_grad():
for data, label in test_loader:
data, label = data.to(device), label.to(device)
output = model(data)
pred = torch.max(output, dim=1)[1]
correct += pred.eq(label).sum().item()
test_acc = correct / len(test_dataset)
test_acc_log.append(test_acc)
lr_scheduler.step()
print(f"Epoch{epoch+1:2d} | Train Loss:{avg_train_loss:.4f} | Test Acc:{test_acc:.4f} | LR:{optimizer.param_groups[0]['lr']:.5f}")2. 关键训练超参数说明
3. 训练过程出现的问题与解决方案
4. 训练输出日志节选## 实验结果1. 定量核心指标
2. 指标变化趋势
3. 可视化成果说明
## 结果分析与总结1. 实验结果深度分析
2. 实验个人理解
3. 改进优化方向
4. 复现说明运行前置依赖： |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-06 分数：95.0/100 评语：报告内容完整、结构清晰，技术实现详实，实验分析深入，具备高度可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-15 手写数字识别程序 —— 基于 PyTorch 的 MNIST CNN 实验1. 实验目标本实验旨在使用**卷积神经网络（CNN）**在经典 MNIST 手写数字数据集上实现高精度数字识别。通过实验掌握核心技能：
2. 数据集2.1 MNIST数据集介绍MNIST是深度学习入门标准手写数字灰度数据集：
2.2 数据加载与预处理预处理逻辑
# 训练集变换（带数据增强）
transform_train = transforms.Compose([
transforms.RandomRotation(10),
transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# 测试集变换（无增强）
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])3. 模型架构3.1 改进LeNet-5双卷积块CNN结构分层尺寸变化如下：
架构设计亮点
3.2 架构选型说明 —— 为何选择CNN而非ResNet等更深网络在模型选型阶段，本实验对比了多种候选架构，最终选择改进版LeNet-5风格的双卷积块CNN，理由如下：
选择CNN的核心原因
4. 训练过程4.1 超参数配置
4.2 完整训练流程
5. 模型评估与结果分析5.1 核心评估指标
5.2 混淆矩阵分析规律手写数字易混淆组合：
5.3 错误样本分析维度
6. 代码规范与工程特性
7. 输出图表文件说明训练结束后项目目录自动生成4个文件：
8. 典型实验结果
9. 运行效率分析与硬件性能指标9.1 训练时间统计
9.2 GPU利用率与内存占用
9.3 效率优化空间分析
10. 完整可运行源代码"""
手写数字识别程序 —— 基于 PyTorch 的 MNIST CNN 实验
=====================================================
本程序实现了一个完整的卷积神经网络（CNN），用于 MNIST 手写数字分类任务。
包含数据加载、模型定义、训练、评估和可视化等完整流程。
作者：课程实验
环境：Python 3.8+, PyTorch 1.10+
"""
# ============================================================
# 第一部分：导入必要的库
# ============================================================
import os
import time
import random
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import rcParams
# 设置 Matplotlib 支持中文显示
rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
rcParams['axes.unicode_minus'] = False
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
# 进度条库
from tqdm import tqdm
# 混淆矩阵
from sklearn.metrics import confusion_matrix
# ============================================================
# 第二部分：超参数配置
# ============================================================
class Config:
"""
超参数配置类
集中管理所有可配置参数，便于修改和复现实验
"""
# 数据相关
BATCH_SIZE = 64 # 每批次训练的样本数量
NUM_WORKERS = 2 # 数据加载的线程数
# 模型相关
INPUT_CHANNELS = 1 # 输入图像通道数（MNIST为灰度图，通道数为1）
NUM_CLASSES = 10 # 输出类别数（数字0-9）
DROPOUT_RATE = 0.25 # Dropout丢弃率
# 训练相关
EPOCHS = 15 # 训练轮数
LEARNING_RATE = 0.001 # 初始学习率
STEP_SIZE = 5 # 学习率衰减的步长（每多少轮衰减一次）
GAMMA = 0.1 # 学习率衰减系数
# 设备相关
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 路径相关
MODEL_SAVE_PATH = 'mnist_cnn_model.pth' # 模型保存路径
PLOT_SAVE_PATH = 'training_curves.png' # 训练曲线保存路径
# 随机种子
SEED = 42
def set_seed(seed=42):
"""
设置随机种子，确保实验结果可复现
参数:
seed: 随机种子值
"""
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# 确保卷积操作的可复现性
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# ============================================================
# 第三部分：数据加载与预处理
# ============================================================
def get_data_loaders(batch_size=64, num_workers=2):
"""
加载 MNIST 数据集并创建数据加载器
数据预处理流程：
1. 训练集：随机旋转、随机平移、转张量、标准化
2. 测试集：转张量、标准化（不做数据增强）
参数:
batch_size: 每批次样本数
num_workers: 数据加载线程数
返回:
train_loader: 训练集数据加载器
test_loader: 测试集数据加载器
"""
# 定义训练集的预处理变换（包含数据增强）
transform_train = transforms.Compose([
# 随机旋转 ±10 度，模拟不同书写角度
transforms.RandomRotation(10),
# 随机平移（水平和垂直方向最多移动10%），模拟数字位置变化
transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
# 将 PIL 图像转换为 PyTorch 张量，并将像素值从 [0,255] 缩放到 [0,1]
transforms.ToTensor(),
# 标准化：使用 MNIST 数据集的全局均值和标准差
# 均值 0.1307，标准差 0.3081
transforms.Normalize((0.1307,), (0.3081,))
])
# 定义测试集的预处理变换（不包含数据增强）
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# 下载并加载训练集
train_dataset = datasets.MNIST(
root='./data', # 数据集保存路径
train=True, # 加载训练集
download=True, # 如果本地没有则自动下载
transform=transform_train # 应用训练集预处理
)
# 下载并加载测试集
test_dataset = datasets.MNIST(
root='./data',
train=False, # 加载测试集
download=True,
transform=transform_test # 应用测试集预处理
)
# 创建训练集数据加载器
train_loader = DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True, # 每轮训练前打乱数据顺序
num_workers=num_workers, # 使用多线程加载数据
pin_memory=True # 加速数据从CPU到GPU的传输
)
# 创建测试集数据加载器
test_loader = DataLoader(
test_dataset,
batch_size=batch_size,
shuffle=False, # 测试集不需要打乱
num_workers=num_workers,
pin_memory=True
)
print(f"训练集样本数: {len(train_dataset)}")
print(f"测试集样本数: {len(test_dataset)}")
return train_loader, test_loader
# ============================================================
# 第四部分：CNN 模型定义
# ============================================================
class CNN(nn.Module):
"""
卷积神经网络模型（MNIST 手写数字识别）
网络结构：
输入(1x28x28) -> 卷积块1 -> 卷积块2 -> 全连接层 -> 输出(10)
详细尺寸变化：
- 输入: [batch_size, 1, 28, 28]
- 卷积块1后: [batch_size, 64, 14, 14]
- 卷积块2后: [batch_size, 64, 7, 7]
- 展平后: [batch_size, 3136]
- 全连接层后: [batch_size, 10]
"""
def __init__(self, num_classes=10, dropout_rate=0.25):
"""
初始化网络结构
参数:
num_classes: 输出类别数（默认10，对应数字0-9）
dropout_rate: Dropout丢弃率
"""
super(CNN, self).__init__()
# ------------------ 第一个卷积块 ------------------
# 输入: [batch, 1, 28, 28]
# 输出: [batch, 32, 28, 28]
self.conv1 = nn.Conv2d(
in_channels=1, # 输入通道数（灰度图为1）
out_channels=32, # 输出通道数（32个卷积核）
kernel_size=3, # 卷积核大小 3x3
padding=1 # 填充1像素，保持输出尺寸不变
)
self.bn1 = nn.BatchNorm2d(32) # 批归一化，稳定训练
# 输入: [batch, 32, 28, 28]
# 输出: [batch, 64, 28, 28]
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.bn2 = nn.BatchNorm2d(64)
# 最大池化：将特征图尺寸减半
# 输入: [batch, 64, 28, 28]
# 输出: [batch, 64, 14, 14]
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
# Dropout：防止过拟合，随机丢弃部分神经元
self.dropout1 = nn.Dropout(dropout_rate)
# ------------------ 第二个卷积块 ------------------
# 输入: [batch, 64, 14, 14]
# 输出: [batch, 64, 14, 14]
self.conv3 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
self.bn3 = nn.BatchNorm2d(64)
# 输入: [batch, 64, 14, 14]
# 输出: [batch, 64, 14, 14]
self.conv4 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
self.bn4 = nn.BatchNorm2d(64)
# 最大池化：将特征图尺寸再次减半
# 输入: [batch, 64, 14, 14]
# 输出: [batch, 64, 7, 7]
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.dropout2 = nn.Dropout(dropout_rate)
# ------------------ 全连接层 ------------------
# 展平后的特征维度：64 * 7 * 7 = 3136
self.fc1 = nn.Linear(64 * 7 * 7, 128) # 降维到128维
self.dropout3 = nn.Dropout(0.5) # 更高的丢弃率
self.fc2 = nn.Linear(128, num_classes) # 输出10个类别
def forward(self, x):
"""
前向传播函数
参数:
x: 输入张量，形状 [batch_size, 1, 28, 28]
返回:
输出张量，形状 [batch_size, 10]
"""
# 第一个卷积块
x = self.conv1(x) # [batch, 1, 28, 28] -> [batch, 32, 28, 28]
x = self.bn1(x)
x = torch.relu(x)
x = self.conv2(x) # [batch, 32, 28, 28] -> [batch, 64, 28, 28]
x = self.bn2(x)
x = torch.relu(x)
x = self.pool1(x) # [batch, 64, 28, 28] -> [batch, 64, 14, 14]
x = self.dropout1(x)
# 第二个卷积块
x = self.conv3(x) # [batch, 64, 14, 14] -> [batch, 64, 14, 14]
x = self.bn3(x)
x = torch.relu(x)
x = self.conv4(x) # [batch, 64, 14, 14] -> [batch, 64, 14, 14]
x = self.bn4(x)
x = torch.relu(x)
x = self.pool2(x) # [batch, 64, 14, 14] -> [batch, 64, 7, 7]
x = self.dropout2(x)
# 展平特征图
# [batch, 64, 7, 7] -> [batch, 3136]
x = x.view(x.size(0), -1)
# 全连接层
x = self.fc1(x) # [batch, 3136] -> [batch, 128]
x = torch.relu(x)
x = self.dropout3(x)
x = self.fc2(x) # [batch, 128] -> [batch, 10]
return x
# ============================================================
# 第五部分：训练函数
# ============================================================
def train_epoch(model, train_loader, criterion, optimizer, device):
"""
训练一个轮次（Epoch）
参数:
model: 神经网络模型
train_loader: 训练数据加载器
criterion: 损失函数
optimizer: 优化器
device: 计算设备（CPU/GPU）
返回:
avg_loss: 平均训练损失
accuracy: 训练准确率
"""
model.train() # 设置为训练模式（启用Dropout和BatchNorm）
total_loss = 0.0 # 累计损失
correct = 0 # 正确预测的样本数
total_samples = 0 # 总样本数
# 使用 tqdm 显示训练进度条
pbar = tqdm(train_loader, desc='训练中', leave=False)
for batch_idx, (images, labels) in enumerate(pbar):
# 将数据移动到指定设备（GPU/CPU）
images = images.to(device)
labels = labels.to(device)
# 清零梯度（防止梯度累积）
optimizer.zero_grad()
# 前向传播：计算模型输出
outputs = model(images)
# 计算损失
loss = criterion(outputs, labels)
# 反向传播：计算梯度
loss.backward()
# 更新模型参数
optimizer.step()
# 统计指标
total_loss += loss.item() * images.size(0)
_, predicted = torch.max(outputs, 1) # 获取预测类别
correct += (predicted == labels).sum().item()
total_samples += labels.size(0)
# 更新进度条显示
current_acc = 100.0 * correct / total_samples
pbar.set_postfix({
'损失': f'{loss.item():.4f}',
'准确率': f'{current_acc:.2f}%'
})
# 计算平均损失和准确率
avg_loss = total_loss / total_samples
accuracy = 100.0 * correct / total_samples
return avg_loss, accuracy
# ============================================================
# 第六部分：评估函数
# ============================================================
def evaluate(model, test_loader, criterion, device):
"""
在测试集上评估模型性能
参数:
model: 神经网络模型
test_loader: 测试数据加载器
criterion: 损失函数
device: 计算设备（CPU/GPU）
返回:
avg_loss: 平均测试损失
accuracy: 测试准确率
all_preds: 所有预测结果
all_labels: 所有真实标签
"""
model.eval() # 设置为评估模式（禁用Dropout，固定BatchNorm）
total_loss = 0.0
correct = 0
total_samples = 0
all_preds = [] # 存储所有预测结果
all_labels = [] # 存储所有真实标签
# 禁用梯度计算（节省内存，加速推理）
with torch.no_grad():
for images, labels in tqdm(test_loader, desc='评估中', leave=False):
images = images.to(device)
labels = labels.to(device)
# 前向传播
outputs = model(images)
# 计算损失
loss = criterion(outputs, labels)
total_loss += loss.item() * images.size(0)
# 获取预测结果
_, predicted = torch.max(outputs, 1)
correct += (predicted == labels).sum().item()
total_samples += labels.size(0)
# 收集预测结果和标签（用于后续分析）
all_preds.extend(predicted.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
avg_loss = total_loss / total_samples
accuracy = 100.0 * correct / total_samples
return avg_loss, accuracy, all_preds, all_labels
# ============================================================
# 第七部分：可视化函数
# ============================================================
def plot_training_curves(history, save_path='training_curves.png'):
"""
绘制训练曲线（损失和准确率）
参数:
history: 训练历史字典，包含 'train_loss', 'train_acc', 'test_loss', 'test_acc'
save_path: 图表保存路径
"""
epochs = range(1, len(history['train_loss']) + 1)
# 创建包含两个子图的画布
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# 子图1：损失曲线
axes[0].plot(epochs, history['train_loss'], 'b-o', label='训练损失', markersize=5)
axes[0].plot(epochs, history['test_loss'], 'r-s', label='测试损失', markersize=5)
axes[0].set_title('损失曲线', fontsize=14, fontweight='bold')
axes[0].set_xlabel('轮次 (Epoch)', fontsize=12)
axes[0].set_ylabel('损失 (Loss)', fontsize=12)
axes[0].legend(fontsize=11)
axes[0].grid(True, linestyle='--', alpha=0.7)
axes[0].set_xticks(epochs)
# 子图2：准确率曲线
axes[1].plot(epochs, history['train_acc'], 'b-o', label='训练准确率', markersize=5)
axes[1].plot(epochs, history['test_acc'], 'r-s', label='测试准确率', markersize=5)
axes[1].set_title('准确率曲线', fontsize=14, fontweight='bold')
axes[1].set_xlabel('轮次 (Epoch)', fontsize=12)
axes[1].set_ylabel('准确率 (%)', fontsize=12)
axes[1].legend(fontsize=11)
axes[1].grid(True, linestyle='--', alpha=0.7)
axes[1].set_xticks(epochs)
axes[1].set_ylim([90, 100]) # 设置y轴范围，更清晰地展示准确率变化
plt.tight_layout()
plt.savefig(save_path, dpi=300, bbox_inches='tight')
print(f"训练曲线已保存至: {save_path}")
plt.show()
def plot_confusion_matrix(y_true, y_pred, save_path='confusion_matrix.png'):
"""
绘制混淆矩阵热力图
参数:
y_true: 真实标签列表
y_pred: 预测标签列表
save_path: 图表保存路径
"""
# 计算混淆矩阵
cm = confusion_matrix(y_true, y_pred)
# 创建图形
fig, ax = plt.subplots(figsize=(10, 8))
# 绘制热力图
im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
ax.figure.colorbar(im, ax=ax)
# 设置坐标轴
ax.set(
xticks=np.arange(cm.shape[1]),
yticks=np.arange(cm.shape[0]),
xticklabels=range(10),
yticklabels=range(10),
xlabel='预测标签',
ylabel='真实标签',
title='混淆矩阵'
)
# 在每个单元格中显示数值
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], 'd'),
ha='center', va='center',
color='white' if cm[i, j] > thresh else 'black',
fontsize=10)
plt.tight_layout()
plt.savefig(save_path, dpi=300, bbox_inches='tight')
print(f"混淆矩阵已保存至: {save_path}")
plt.show()
def plot_predictions(model, test_loader, device, num_samples=10, save_path='predictions.png'):
"""
可视化模型的预测样例
参数:
model: 神经网络模型
test_loader: 测试数据加载器
device: 计算设备
num_samples: 展示的样本数量
save_path: 图表保存路径
"""
model.eval()
# 获取一批测试数据
data_iter = iter(test_loader)
images, labels = next(data_iter)
images = images.to(device)
# 预测
with torch.no_grad():
outputs = model(images)
_, predicted = torch.max(outputs, 1)
# 将数据移回 CPU 并转换为 numpy
images = images.cpu().numpy()
labels = labels.numpy()
predicted = predicted.cpu().numpy()
# 创建子图
fig, axes = plt.subplots(2, 5, figsize=(15, 7))
axes = axes.flatten()
for i in range(num_samples):
# 显示图像（需要反标准化）
img = images[i].squeeze() # 移除通道维度 [1, 28, 28] -> [28, 28]
img = img * 0.3081 + 0.1307 # 反标准化
img = np.clip(img, 0, 1)
axes[i].imshow(img, cmap='gray')
# 设置标题：显示真实标签和预测结果
is_correct = labels[i] == predicted[i]
color = 'green' if is_correct else 'red'
title = f'真实: {labels[i]}\n预测: {predicted[i]}'
axes[i].set_title(title, color=color, fontsize=12)
axes[i].axis('off')
plt.suptitle('手写数字识别预测样例（绿色=正确，红色=错误）', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig(save_path, dpi=300, bbox_inches='tight')
print(f"预测样例已保存至: {save_path}")
plt.show()
# ============================================================
# 第八部分：主函数
# ============================================================
def main():
"""
主函数：组织完整的训练和评估流程
"""
print("=" * 60)
print("手写数字识别程序 —— MNIST CNN 实验")
print("=" * 60)
# 设置随机种子
set_seed(Config.SEED)
print(f"随机种子已设置为: {Config.SEED}")
# 显示使用的计算设备
print(f"使用设备: {Config.DEVICE}")
if Config.DEVICE.type == 'cuda':
print(f"GPU 型号: {torch.cuda.get_device_name(0)}")
# 加载数据
print("\n【步骤 1/5】加载数据集...")
train_loader, test_loader = get_data_loaders(
batch_size=Config.BATCH_SIZE,
num_workers=Config.NUM_WORKERS
)
# 初始化模型
print("\n【步骤 2/5】初始化模型...")
model = CNN(
num_classes=Config.NUM_CLASSES,
dropout_rate=Config.DROPOUT_RATE
).to(Config.DEVICE)
# 打印模型结构
print("\n模型结构:")
print(model)
# 统计模型参数量
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"\n总参数量: {total_params:,}")
print(f"可训练参数量: {trainable_params:,}")
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss() # 交叉熵损失（适合多分类）
optimizer = optim.Adam(
model.parameters(),
lr=Config.LEARNING_RATE
)
# 学习率调度器：每 STEP_SIZE 轮将学习率乘以 GAMMA
scheduler = StepLR(
optimizer,
step_size=Config.STEP_SIZE,
gamma=Config.GAMMA
)
# 初始化训练历史记录
history = {
'train_loss': [],
'train_acc': [],
'test_loss': [],
'test_acc': []
}
# 训练循环
print("\n【步骤 3/5】开始训练...")
print("-" * 60)
best_acc = 0.0 # 记录最佳测试准确率
for epoch in range(1, Config.EPOCHS + 1):
start_time = time.time()
# 训练一个轮次
train_loss, train_acc = train_epoch(
model, train_loader, criterion, optimizer, Config.DEVICE
)
# 在测试集上评估
test_loss, test_acc, _, _ = evaluate(
model, test_loader, criterion, Config.DEVICE
)
# 更新学习率
scheduler.step()
current_lr = optimizer.param_groups[0]['lr']
# 记录历史
history['train_loss'].append(train_loss)
history['train_acc'].append(train_acc)
history['test_loss'].append(test_loss)
history['test_acc'].append(test_acc)
# 保存最佳模型
if test_acc > best_acc:
best_acc = test_acc
torch.save(model.state_dict(), Config.MODEL_SAVE_PATH)
best_flag = " ★ 最佳模型"
else:
best_flag = ""
epoch_time = time.time() - start_time
# 输出本轮训练结果
print(f"轮次 [{epoch:2d}/{Config.EPOCHS}] | "
f"训练损失: {train_loss:.4f} | 训练准确率: {train_acc:.2f}% | "
f"测试损失: {test_loss:.4f} | 测试准确率: {test_acc:.2f}% | "
f"学习率: {current_lr:.6f} | "
f"耗时: {epoch_time:.1f}s{best_flag}")
print("-" * 60)
print(f"训练完成！最佳测试准确率: {best_acc:.2f}%")
# 加载最佳模型进行后续分析
model.load_state_dict(torch.load(Config.MODEL_SAVE_PATH))
print(f"已加载最佳模型: {Config.MODEL_SAVE_PATH}")
# 最终评估
print("\n【步骤 4/5】最终评估...")
final_loss, final_acc, all_preds, all_labels = evaluate(
model, test_loader, criterion, Config.DEVICE
)
print(f"最终测试损失: {final_loss:.4f}")
print(f"最终测试准确率: {final_acc:.2f}%")
# 可视化
print("\n【步骤 5/5】生成可视化图表...")
# 绘制训练曲线
plot_training_curves(history, save_path=Config.PLOT_SAVE_PATH)
# 绘制混淆矩阵
plot_confusion_matrix(all_labels, all_preds, save_path='confusion_matrix.png')
# 绘制预测样例
plot_predictions(model, test_loader, Config.DEVICE, save_path='predictions.png')
print("\n" + "=" * 60)
print("实验完成！")
print("=" * 60)
# ============================================================
# 程序入口
# ============================================================
if __name__ == '__main__':
main()11. 运行说明11.1 环境依赖
11.2 一键安装依赖pip install torch torchvision numpy matplotlib scikit-learn tqdm11.3 启动运行将代码保存为 python mnist_cnn.py12. 实验总结本实验完整复现深度学习图像分类工业流程，以改进LeNet CNN完成MNIST手写数字高精度识别。通过数据增强、BN归一化、分层Dropout、自适应学习率调度多重优化，稳定突破99%测试准确率。 核心收获
|
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-15 分数：97.0/100 评语：报告内容完整、技术理解深入，代码规范且可复现，实验结果详实，分析全面。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2503-14 计算机视觉应用程序报告：手写数字识别系统
1. 项目简介本项目实现了一个手写数字识别应用，目标是让计算机识别用户输入的单个手写数字，并输出 0 到 9 中最可能的类别。项目包含数据生成、图像预处理、模型训练、模型保存、单张图片预测和可交互手写板 demo，形成了一个完整的计算机视觉应用流程。 与直接调用成熟深度学习框架不同，本项目使用 Python、NumPy 和 Pillow 完成主要功能，并用 NumPy 从零实现一个一层隐藏层的多层感知机分类器。这样既能完成识别任务，也能比较清楚地展示图像分类程序从输入图片到输出类别的全过程。 项目主要功能如下：
2. 选题背景与意义手写数字识别是计算机视觉中的经典图像分类任务。虽然任务本身较小，但它包含了视觉识别系统的核心流程：图像采集、预处理、特征表达、模型推理和结果展示。通过实现该项目，可以理解机器学习模型如何将图像像素映射到语义类别。 该任务在现实中也有很多类似应用，例如：
本项目选择手写数字识别作为计算机视觉应用，是因为它数据规模适中、结果直观、交互展示方便，同时适合展示完整的 AI 应用开发过程。 3. 需求分析3.1 输入需求程序支持两类输入：
无论输入图片尺寸、背景颜色和数字位置如何变化，程序都需要把它们转换为模型可接受的统一格式。 3.2 输出需求程序输出内容包括：
3.3 性能与可用性需求
4. 开发环境
安装依赖： pip install -r requirements.txt训练模型： cd handwritten_digit_recognition
python train.py --epochs 60 --samples 35 --fonts 12启动手写板 demo： python app.py预测单张图片： python predict.py demo/test_digit_5_correct.png5. 系统总体设计项目目录结构如下： 系统处理流程如下： flowchart TD
A["输入图像或手写板画布"] --> B["灰度化与反色处理"]
B --> C["数字区域裁剪"]
C --> D["缩放并居中到 28x28"]
D --> E["MLP 模型推理"]
E --> F["输出预测数字与概率"]
整体流程可以分为训练阶段和预测阶段：
6. 数据集与图像预处理6.1 数据来源由于实验环境不一定能稳定下载 MNIST 数据集，本项目采用本机字体合成数字数据。程序会扫描系统字体目录，将每个数字渲染成图片，并通过随机增强模拟不同书写风格。 本次训练数据配置如下：
6.2 数据增强为了让模型见到更多形态差异，数据生成阶段加入了轻量增强：
6.3 图像预处理图像预处理是本项目中非常关键的一步。模型只能接收 28x28 的一维向量，因此需要将不同来源的图片统一到相同格式。 预处理步骤：
核心预处理代码如下： def preprocess_image(image):
gray = image.convert("L")
arr = np.asarray(gray, dtype=np.uint8)
if arr.mean() > 127:
arr = 255 - arr
bbox = _bounding_box(arr)
if bbox is None:
return np.zeros((28 * 28,), dtype=np.float32)
digit = Image.fromarray(arr).crop(bbox)
digit.thumbnail((20, 20), Image.Resampling.LANCZOS)
canvas = Image.new("L", (28, 28), 0)
canvas.paste(digit, ((28 - digit.width) // 2, (28 - digit.height) // 2))
return (np.asarray(canvas, dtype=np.float32) / 255.0).reshape(-1)预处理的意义是减少输入图片中无关因素的影响，让模型重点学习数字笔画本身，而不是图片尺寸、背景颜色或数字位置。 7. 算法原理本项目使用多层感知机 MLP 完成 0-9 数字分类。模型输入为 28x28 灰度图展开后的 784 维向量，输出为 10 个类别的概率。 模型结构如下：
前向传播公式： 其中：
Softmax 将模型输出转换为概率分布，预测时选择概率最大的类别作为最终结果。 z1 = x @ self.w1 + self.b1
h = np.maximum(z1, 0)
logits = h @ self.w2 + self.b2
logits -= logits.max(axis=1, keepdims=True)
exp = np.exp(logits)
probs = exp / exp.sum(axis=1, keepdims=True)训练目标使用交叉熵损失。对于正确类别，模型需要让该类别概率尽可能高；对于其他类别，概率应尽可能低。训练时使用小批量梯度下降，并加入 L2 正则化来减轻过拟合。 8. 关键功能实现8.1 模型训练模块
训练完成后会生成：
8.2 图片预测模块
运行示例： python predict.py demo/test_digit_5_correct.png输出结果： 从结果可以看出，模型将该测试图片识别为数字 5，预测概率为 0.9644，说明模型对该样本具有较高置信度。 8.3 手写板 demo 模块
手写板功能如下：
识别逻辑如下： vector = preprocess_image(self.image)
probs = self.model.predict_proba(vector)[0]
prediction = int(probs.argmax())
confidence = float(probs[prediction])该 demo 体现了计算机视觉程序从用户输入、图像处理、模型预测到界面反馈的完整应用链路。 9. 实验结果9.1 训练结果本次训练结果如下：
训练日志节选： 从训练结果可以看出，模型在合成数据验证集上的准确率达到 99.82%。这说明在当前数据分布下，MLP 已经能够较好地区分 0-9 数字。 9.2 单图预测结果使用
模型预测结果为数字 5，概率明显高于其他类别。 9.3 运行截图训练样本预览图：
单张预测测试图：
手写板运行界面截图：
10. 结果分析实验结果表明，本项目能够完成基本的手写数字识别任务。模型在验证集上的准确率较高，说明数据预处理、模型结构和训练流程是有效的。 本项目效果较好的原因主要有：
同时也要注意，当前验证集来自同一套合成数据生成流程，因此验证准确率不能完全代表真实手写场景的效果。真实用户手写时，可能出现笔画连写、数字过小、数字靠边、形状过于个性化等问题，这些情况会降低识别准确率。 11. 遇到的问题与解决方法
12. 改进方向后续可以从以下方向继续优化：
13. 项目总结本项目完成了一个可运行的计算机视觉应用：手写数字识别系统。项目从数据生成开始，经过图像预处理、模型训练、模型保存、图片预测和手写板交互，最终形成了一个完整的 AI 应用闭环。 通过本项目，我对计算机视觉应用有了更具体的理解。图像识别并不是只训练一个模型，还需要处理输入数据格式、图像尺寸、背景颜色、目标位置、模型保存和用户交互等问题。特别是在手写数字识别中，预处理对最终效果影响很大。如果数字没有被正确裁剪、缩放和居中，即使模型本身训练效果较好，也可能在实际输入中出现误判。 本项目也让我理解了 MLP 分类器的基本原理。输入图片被展开为像素向量后，模型通过隐藏层学习数字形状特征，再通过 Softmax 输出各类别概率。虽然 MLP 没有 CNN 那样强的空间特征提取能力，但对于 28x28 的简单数字分类任务已经可以达到较好的效果。 整体来看，该项目达到了课程实践目标：程序能够运行，功能完整，实验指标明确，报告能够说明设计思路、算法原理和实验结果。后续如果使用真实手写数据和卷积神经网络，系统的实际泛化能力还可以进一步提升。 14. 参考资料 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2503-14 分数：93.0/100 评语：报告内容完整、结构清晰，技术实现与分析深入，实验结果展示充分，具备可复现性。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-31 一、项目目标与应用场景 1.1 实验目标 本实验旨在利用卷积神经网络（CNN）对 CIFAR-10 数据集中的 10 类彩色图像进行分类。CIFAR-10 相比 MNIST 更具挑战性——图像为 32×32 彩色图，包含飞机、汽车、鸟、猫、鹿、狗、蛙、马、船、卡车共 10 个类别，物体存在姿态、光照、背景等丰富变化。实验具体目标包括： · 构建适用于中等复杂度图像分类的 CNN 模型； 1.2 应用场景 本任务的技术可直接迁移至多种真实视觉应用： · 智能安防：自动识别监控画面中的车辆、动物或行人； 二、数据集与数据处理 2.1 数据集来源与特点 CIFAR-10 由加拿大高等研究院发布，包含 60,000 张 32×32 的 RGB 彩色图像，其中训练集 50,000 张，测试集 10,000 张，每类图像数量均衡（各 6,000 张）。该数据集的特点在于： · 类内差异大：同一类别（如“猫”）可能呈现不同颜色、姿势和背景； 2.2 数据预处理方法 from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
# 加载数据
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# 归一化到 [0, 1] 区间（加速收敛，避免梯度震荡）
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0
# One-Hot 编码（适配分类交叉熵损失）
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)数据增强（在线进行） ：为扩充有效训练样本并提升泛化能力，使用 ImageDataGenerator 实时生成变形图像： from tensorflow.keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
horizontal_flip=True, # 水平翻转（对左右对称物体有效）
width_shift_range=0.2, # 水平偏移 20%
height_shift_range=0.2, # 垂直偏移 20%
rotation_range=15 # 随机旋转 ±15°
)
datagen.fit(X_train)增强后的图像模拟了真实拍摄中的视角变化，使模型对平移、旋转和翻转更具鲁棒性。 三、模型或技术方案 3.1 网络架构设计 采用 3 个卷积块 + 全连接层 的结构，在模型容量与轻量化之间取得平衡。具体参数如下： 层序号 层类型 参数 / 尺寸 输出尺寸 3.2 方案选择原因 · 3×3 小卷积核：在保持感受野的同时大幅减少参数量，且多层堆叠能增强非线性表达能力。 四、实现与训练过程 4.1 完整代码实现 import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.optimizers import Adam
from sklearn.metrics import confusion_matrix
import seaborn as sns
# ========== 1. 数据加载与预处理 ==========
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0
y_train_cat = to_categorical(y_train, 10)
y_test_cat = to_categorical(y_test, 10)
# ========== 2. 数据增强器 ==========
datagen = ImageDataGenerator(
horizontal_flip=True,
width_shift_range=0.2,
height_shift_range=0.2,
rotation_range=15
)
datagen.fit(X_train)
# ========== 3. 构建 CNN 模型 ==========
model = Sequential([
Conv2D(32, (3,3), activation='relu', padding='same', input_shape=(32,32,3)),
BatchNormalization(),
MaxPooling2D((2,2)),
Conv2D(64, (3,3), activation='relu', padding='same'),
BatchNormalization(),
MaxPooling2D((2,2)),
Conv2D(128, (3,3), activation='relu', padding='same'),
BatchNormalization(),
MaxPooling2D((2,2)),
Flatten(),
Dense(256, activation='relu'),
Dropout(0.5),
Dense(10, activation='softmax')
])
model.summary()
# ========== 4. 编译 ==========
model.compile(
optimizer=Adam(learning_rate=0.001),
loss='categorical_crossentropy',
metrics=['accuracy']
)
# ========== 5. 训练 ==========
history = model.fit(
datagen.flow(X_train, y_train_cat, batch_size=64),
epochs=30,
validation_data=(X_test, y_test_cat),
verbose=1
)
# ========== 6. 评估 ==========
test_loss, test_acc = model.evaluate(X_test, y_test_cat, verbose=0)
print(f"测试集准确率: {test_acc:.4f}")
# ========== 7. 混淆矩阵 ==========
y_pred = np.argmax(model.predict(X_test), axis=-1)
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8,6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=['airplane','car','bird','cat','deer','dog','frog','horse','ship','truck'],
yticklabels=['airplane','car','bird','cat','deer','dog','frog','horse','ship','truck'])
plt.title('Confusion Matrix')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.show()
# ========== 8. 训练曲线 ==========
plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(history.history['accuracy'], label='Train Acc')
plt.plot(history.history['val_accuracy'], label='Val Acc')
plt.xlabel('Epoch'); plt.ylabel('Accuracy'); plt.legend(); plt.title('Accuracy Curves')
plt.subplot(1,2,2)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Val Loss')
plt.xlabel('Epoch'); plt.ylabel('Loss'); plt.legend(); plt.title('Loss Curves')
plt.show()4.2 关键参数与训练过程 参数 取值 理由 采用 数据增强流 输入，每个 epoch 看到的是动态生成的变形图像，等效训练样本量被无限放大。前 10 个 epoch 准确率快速攀升至 ~70%，之后逐渐趋缓，最终在 30 个 epoch 时达到稳定。 五、实验结果 5.1 量化指标 指标 数值 5.2 混淆矩阵与曲线分析 · 准确率曲线：训练集准确率持续上升至 91%，验证准确率稳定在 82% 左右，两者差距约 9%，表明存在一定过拟合，但 Dropout 和增强已有效缓解。 六、结果分析与总结 6.1 结果分析
6.2 个人理解与改进方向 · 数据增强的价值：虽未增加真实样本，但通过几何变换让模型看到了“无限”的变体，实质是引入了先验知识（平移/翻转不变性），极大提升了泛化能力。 6.3 总结 本实验完整实现了基于 CNN 的 CIFAR-10 图像分类，从数据预处理、模型设计、训练调优到结果分析，全面覆盖了计算机视觉任务的典型流程。最终 82.3% 的准确率验证了方案的有效性，同时通过对混淆矩阵和训练曲线的分析，加深了对过拟合、数据增强和网络结构设计的理解。该实践为后续处理更复杂视觉任务（如目标检测、语义分割）奠定了扎实的基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-31 分数：93.0/100 评语：报告结构完整、内容详实，技术理解深入，代码与实验结果展示规范，分析到位。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
-
|
编号：2501-07 一、项目目标与应用场景 1.1 实验目标 本实验使用 迁移学习 方法对 CIFAR-10 图像进行分类，采用预训练的 MobileNetV2 作为特征提取器，并在其基础上进行微调。实验目标包括： · 熟悉迁移学习的完整流程（加载预训练权重、冻结/解冻层、分阶段微调）； 1.2 应用场景 迁移学习技术在实际工业界被广泛采用，主要应用包括： · 医疗影像辅助诊断：利用 ImageNet 预训练模型快速构建肺结节、眼底病变等分类器，缓解医疗数据标注不足的问题； 二、数据集与数据处理 2.1 数据集来源与特点 CIFAR-10 数据集包含 60,000 张 32×32 的彩色图像，共 10 个类别，每类 6,000 张。其中训练集 50,000 张，测试集 10,000 张。该数据集的挑战在于：图像分辨率低、类内差异大（同一物体在不同光照/角度下变化）、部分类别高度相似（猫 vs 狗，汽车 vs 卡车）。 由于 MobileNetV2 预训练模型通常接受 224×224 的输入图像，若直接输入 32×32 的图像，预训练权重中学习的卷积核感受野将严重不匹配。因此本实验将图像 上采样至 96×96（常用轻量级模型输入尺寸），在保留较多细节的同时控制计算量。 2.2 数据预处理方法 import numpy as np
import cv2
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
# 加载原始数据
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 上采样函数：将 32x32 放大到 96x96（双线性插值）
def resize_images(images, target_size=(96, 96)):
n = images.shape[0]
resized = np.zeros((n, target_size[0], target_size[1], 3), dtype='float32')
for i in range(n):
resized[i] = cv2.resize(images[i], target_size, interpolation=cv2.INTER_LINEAR)
return resized
X_train = resize_images(X_train)
X_test = resize_images(X_test)
# MobileNetV2 专用预处理：将 [0,255] 像素值映射到 [-1, 1]（与训练时一致）
X_train = preprocess_input(X_train)
X_test = preprocess_input(X_test)
# One-Hot 编码
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)数据增强策略：为了充分发挥预训练模型的泛化能力并防止过拟合，采用较强的在线数据增强： from tensorflow.keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
horizontal_flip=True, # 水平翻转（适合左右对称物体）
width_shift_range=0.15, # 水平平移 15%
height_shift_range=0.15, # 垂直平移 15%
rotation_range=20, # 随机旋转 ±20°
zoom_range=0.15, # 随机缩放 85%~115%
fill_mode='nearest' # 填充方式
)
datagen.fit(X_train)增强后的图像模拟了不同拍摄角度、距离和翻转变化，能显著提升模型的鲁棒性。 三、模型或技术方案 3.1 网络架构设计 本实验采用 MobileNetV2 作为基础模型（在 ImageNet 上预训练），移除原始顶部的全连接分类层，替换为适合 CIFAR-10 的定制分类头。具体结构如下： 层序号 层类型 参数说明 输出尺寸 分阶段训练策略： · 阶段一（冻结主体） ：将 MobileNetV2 的全部卷积层冻结（trainable=False），仅训练新添加的分类头，学习率设为 1e-3，训练 10 个 epoch。 3.2 方案选择原因 · MobileNetV2 的轻量级优势：采用深度可分离卷积，参数量远小于 VGG/ResNet，在保证精度的同时适合资源受限场景（如手机端部署）。 四、实现与训练过程 4.1 完整代码实现 import numpy as np
import matplotlib.pyplot as plt
import cv2
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Model
from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# ==================== 1. 数据加载与预处理 ====================
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
def resize_images(images, target_size=(96, 96)):
n = images.shape[0]
resized = np.zeros((n, target_size[0], target_size[1], 3), dtype='float32')
for i in range(n):
resized[i] = cv2.resize(images[i], target_size, interpolation=cv2.INTER_LINEAR)
return resized
X_train = resize_images(X_train)
X_test = resize_images(X_test)
X_train = preprocess_input(X_train)
X_test = preprocess_input(X_test)
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
# ==================== 2. 数据增强 ====================
datagen = ImageDataGenerator(
horizontal_flip=True,
width_shift_range=0.15,
height_shift_range=0.15,
rotation_range=20,
zoom_range=0.15,
fill_mode='nearest'
)
datagen.fit(X_train)
# ==================== 3. 构建迁移学习模型 ====================
# 加载预训练 MobileNetV2（不包含顶层）
base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(96, 96, 3))
base_model.trainable = False # 初始冻结全部卷积层
# 添加自定义分类头
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(128, activation='relu')(x)
x = Dropout(0.3)(x)
predictions = Dense(10, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
model.summary()
# ==================== 4. 第一阶段：训练分类头 ====================
model.compile(optimizer=Adam(learning_rate=1e-3),
loss='categorical_crossentropy',
metrics=['accuracy'])
history1 = model.fit(
datagen.flow(X_train, y_train, batch_size=32),
epochs=10,
validation_data=(X_test, y_test),
verbose=1
)
# ==================== 5. 第二阶段：微调部分卷积层 ====================
# 解冻最后 10 层卷积层
base_model.trainable = True
for layer in base_model.layers[:-10]:
layer.trainable = False # 保持前层冻结
# 重新编译（使用更低学习率）
model.compile(optimizer=Adam(learning_rate=1e-5),
loss='categorical_crossentropy',
metrics=['accuracy'])
history2 = model.fit(
datagen.flow(X_train, y_train, batch_size=32),
epochs=10,
validation_data=(X_test, y_test),
verbose=1
)
# ==================== 6. 最终评估 ====================
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print(f"\n测试集准确率: {test_acc:.4f}")
print(f"测试集损失: {test_loss:.4f}")
# ==================== 7. 绘制训练曲线 ====================
# 合并两阶段的 history
acc = history1.history['accuracy'] + history2.history['accuracy']
val_acc = history1.history['val_accuracy'] + history2.history['val_accuracy']
loss = history1.history['loss'] + history2.history['loss']
val_loss = history1.history['val_loss'] + history2.history['val_loss']
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(acc, label='Train Acc')
plt.plot(val_acc, label='Val Acc')
plt.axvline(x=9.5, color='r', linestyle='--', label='Start Fine-tune')
plt.xlabel('Epoch'); plt.ylabel('Accuracy'); plt.legend(); plt.title('Accuracy Curves')
plt.subplot(1, 2, 2)
plt.plot(loss, label='Train Loss')
plt.plot(val_loss, label='Val Loss')
plt.axvline(x=9.5, color='r', linestyle='--', label='Start Fine-tune')
plt.xlabel('Epoch'); plt.ylabel('Loss'); plt.legend(); plt.title('Loss Curves')
plt.tight_layout()
plt.show()4.2 关键参数与训练过程 阶段 优化器 学习率 批次大小 轮数 可训练层 训练过程观察： · 第一阶段：前 3 个 epoch 验证准确率从随机（~10%）快速升至 ~70%，第 10 个 epoch 达到约 82%。训练曲线平滑，无明显震荡。 五、实验结果 5.1 量化指标 指标 数值 5.2 结果对比分析 方法 测试准确率 说明 · 准确率曲线：第一阶段结束时验证准确率约为 82%，与从头训练的 CNN 相当；第二阶段微调后进一步提升至 86.2%，证明了高层特征适配的有效性。 六、结果分析与总结 6.1 结果分析
6.2 个人理解 · 为什么底层不微调？：CNN 底层学习的边缘、颜色斑块等特征在自然图像中是通用的（Gabor 滤波器、色彩响应），ImageNet 和 CIFAR-10 的底层视觉分布高度一致，因此冻结底层不仅节省计算量，还能避免在小数据集上对这些通用特征的过拟合。 6.3 改进方向 · 增大输入尺寸：尝试 128×128 或 224×224，可能进一步提升精度（需平衡计算资源）； 6.4 总结 本实验成功运用迁移学习方法，基于 MobileNetV2 预训练模型对 CIFAR-10 进行分类，测试准确率达到 86.2%，相较于从头训练的 CNN（82.3%）有明显提升。通过分阶段微调和数据增强策略，有效控制了过拟合并充分适配了目标数据集。实验完整覆盖了迁移学习的核心流程：加载预训练权重、冻结/解冻层设计、双阶段训练、结果对比与分析。这一技术范式在处理实际视觉任务（尤其是数据量有限的情况下）具有很高的实用价值，为后续学习目标检测、语义分割等复杂任务提供了坚实的技术基础。 |
Beta Was this translation helpful? Give feedback.
-
|
自动批改反馈： 编号：2501-07 分数：97.0/100 评语：报告内容完整、结构清晰，技术理解深入，代码实现规范且可复现，实验结果详实并配有分析与改进方向。 优点：
建议：
说明：本反馈由大模型辅助生成，最终结果以老师复核为准。 |
Beta Was this translation helpful? Give feedback.
and others
Uh oh!
There was an error while loading. Please reload this page.
-
本 Discussion 用于提交“实践2：计算机视觉应用”的 GitHub 文字版报告，并用于 AI 辅助批改和成绩登记。本项满分 20 分。
提交格式
回复开头必须填写：
推荐使用 Markdown，参考结构：
报告内容
请至少包含：
评分说明
主要根据报告内容完整性、技术方案、代码质量、实验过程、成果展示和结果分析进行评价。Markdown 结构清晰、代码块和图表说明规范，可获得少量表达加分；纯文字也可以提交，但应保证分段清楚、内容完整。
明显空白、跑题、无实际实验内容或复制无关材料的回复不视为有效提交。
Word 留存版
还需提交内容基本一致的
.doc或.docx文件，文件名：Word 上传入口另行发布。不要在公开回复中填写真实姓名、学号或联系方式。
Beta Was this translation helpful? Give feedback.
All reactions