使用yolo训练自己的模型

YOLO（You Only Look Once）是一种用于目标检测的深度学习模型，旨在实时检测图像或视频中的多个对象。与传统的目标检测方法不同，YOLO一次性处理整个图像，而不是通过滑动窗口或区域提议进行多次检测。这种方法使得YOLO在速度上具有显著优势，能够实现实时目标检测。

以下是YOLO的一些关键特点：

1. One-shot Detection： YOLO的主要特点是一次性完成整个图像的目标检测，而不是像其他方法那样需要多次扫描图像。

2. 实时性能： YOLO被设计为高效实时运行，尤其适用于需要快速处理大量数据的应用，如视频监控、自动驾驶等。

3. Anchor Boxes： YOLO使用先验框（Anchor Boxes）来预测目标的位置和大小。这些锚框表示了模型预测的目标的一些常见形状，有助于提高检测准确性。

4. 分组预测： YOLO将图像分为较小的网格，每个网格负责预测一个或多个目标。这有助于提高模型对多尺度和多类别目标的检测能力。

5. 多尺度特征图： YOLO通过使用多个尺度的特征图来捕捉图像中不同层次的语义信息，这有助于提高对小目标和远距离目标的检测性能。

6. 全卷积网络： YOLO采用全卷积网络结构，使得模型可以接受任意大小的输入图像，并在输出中产生相应大小的目标框。

7. 多类别检测： YOLO可以同时检测多个类别的目标，每个目标框附带一个置信度得分，表示该框中存在目标的置信水平。

YOLO的最新版本可能有一些改进和变化，因此在组会中最好使用最新的文档或论文进行参考。

8. 训练过程： YOLO的训练过程通常包括两个主要阶段：首先，通过预训练的卷积神经网络（如Darknet）进行特征学习；然后，通过调整网络参数以适应目标检测任务。训练过程中需要使用标记好的包含目标边界框和类别信息的训练集。

9. 非极大值抑制（NMS）： 为了排除冗余的检测框，YOLO使用非极大值抑制。在多个检测框重叠的情况下，NMS算法会选择具有最高置信度得分的框，并抑制其他重叠框。

10. 适用领域： YOLO广泛应用于计算机视觉领域，包括物体检测、行人检测、交通标志检测、医学图像分析等。其快速的实时性能使其成为许多实际应用的首选。

11. 版本演进： YOLO模型有多个版本，每个版本都对算法和性能进行了改进。YOLOv4和YOLOv5是其中较新的版本，它们通过引入新的技术和优化提高了检测精度和速度。

12. 开源： YOLO是一个开源项目，使得研究人员和开发者能够自由使用、修改和扩展该模型。YOLO的开源性质促进了社区合作和在不同领域的广泛应用。

13. YOLO模型结构： YOLO的网络结构通常由多个卷积层、池化层和全连接层组成。这些层构成了一个端到端的神经网络，负责提取输入图像的特征并输出目标框的坐标和类别信息。YOLO的网络结构是相对简洁的，这有助于实现高效的目标检测。

14. 损失函数： YOLO使用多任务学习，其损失函数包括位置损失、对象置信度损失和类别置信度损失。位置损失衡量了目标框位置的精确度，对象置信度损失评估了模型对目标存在的置信度，而类别置信度损失则衡量了目标类别的分类准确度。这些损失函数的综合作用有助于优化模型，使其能够准确地检测和定位目标。

15. 训练策略： YOLO的训练通常需要使用大规模的标记数据集，其中包含了各种目标和场景。训练时，模型通过反向传播和梯度下降等优化算法来不断调整权重，使得预测结果更加接近真实标签。合适的学习率调度和数据增强等策略也是训练中常用的技巧。

16. 硬件加速： 为了在实际应用中提高YOLO的推理速度，一些版本的YOLO模型支持在不同硬件上进行加速，如GPU和NPU。这些硬件加速方法有助于满足实时性要求，特别是在需要处理大规模图像或视频流的场景中。

17. 应用案例： YOLO已经在多个领域取得了成功应用，包括智能监控、自动驾驶、医学影像分析、无人机技术等。其高效的实时检测性能使得它在许多实际应用中成为首选的目标检测算法。

训练与训练数据输入部分：

1. 数据准备： 准备标注好的训练数据集，其中每个样本都包含目标的边界框坐标和类别信息。确保数据集的多样性，涵盖了模型可能在实际应用中遇到的各种场景和目标。

2. 数据预处理： 对训练数据进行预处理，包括图像大小的标准化、归一化、数据增强等操作。数据增强可以通过随机旋转、翻转、裁剪等方式增加训练数据的多样性，有助于提升模型的泛化能力。

3. 模型配置： 选择合适的YOLO模型版本（如YOLOv4、YOLOv5等）和相应的配置文件。配置文件中包含了网络结构的参数、训练参数、学习率、锚框等信息。

4. 权重初始化： 使用预训练的卷积神经网络权重初始化模型。通常可以使用在大规模图像分类任务上预训练的权重，以加速模型收敛。

5. 模型训练： 利用标注好的训练数据集进行模型训练。通过反向传播和梯度下降等优化算法，不断调整模型的权重，使其能够准确地检测目标。训练过程中，监控模型在验证集上的性能以及损失函数的变化，确保模型在训练过程中逐渐收敛。

6. 学习率调度： 使用合适的学习率调度策略，如学习率衰减或学习率周期性调整，以优化模型的收敛速度和稳定性。

模型评估方式与具体实现方法：

1. 评估指标： YOLO模型的性能通常通过目标检测任务中常用的指标进行评估，包括准确率（Precision）、召回率（Recall）、F1分数等。除此之外，可以使用均方误差（Mean Squared Error，MSE）来评估目标框坐标的精度。

2. 验证集评估： 在训练过程中，使用预留的验证集进行定期的模型性能评估。验证集上的评估结果可以帮助确定模型是否过拟合或欠拟合，并指导是否需要调整模型架构或超参数。

3. 非极大值抑制（NMS）： 在模型输出目标框后，使用NMS算法来抑制冗余的检测框，以提高模型的检测精度。NMS的实现通常涉及设置一个阈值来确定是否合并相邻的检测框。

4. 可视化分析： 利用可视化工具分析模型在测试集上的预测结果，查看模型是否成功检测出目标、框的位置是否准确，以及对不同类别的检测效果如何。

5. 指标曲线： 绘制学习曲线、损失函数曲线以及评估指标随训练次数的变化曲线，以更全面地了解模型的训练过程和性能。

6. 模型保存与部署： 在满足性能要求后，保存训练好的模型权重。随后，可以将模型部署到实际应用中，例如嵌入式系统、服务器端或移动端，实现目标检测的实时应用。

实现方式

实现一个YOLO项目通常涉及以下步骤：

1. 准备工作：

   • 安装深度学习框架：确保你已经安装了你选择的深度学习框架，如TensorFlow或PyTorch。
   • 安装YOLO模型：下载或克隆YOLO模型的代码库，例如Darknet（YOLO官方实现）或YOLOv5的代码库。

2. 数据集准备：

   • 收集或获取目标检测任务的标注好的数据集，确保数据集包含了目标类别的图像以及相应的标签信息。
   • 数据预处理：对数据集进行预处理，包括图像大小的调整、归一化、数据增强等，以提高模型的泛化能力。

3. 配置模型：

   • 配置模型参数：根据你的任务需求，选择合适的YOLO模型版本（如YOLOv3、YOLOv4、YOLOv5等），并设置相应的超参数，如学习率、批量大小等。
   • 配置模型结构：修改网络结构的配置文件，定义模型的层数、锚框、类别数等。

4. 权重初始化：

   • 使用预训练权重：在模型训练之前，可以使用在大规模图像分类任务上预训练的权重来初始化模型。这有助于模型更快速地学习目标检测任务。

5. 模型训练：

   • 输入训练数据：将预处理过的训练数据输入模型。
   • 定义损失函数：YOLO模型通常使用多任务学习，需要定义位置损失、对象置信度损失和类别置信度损失。
   • 反向传播和优化：使用梯度下降等优化算法进行反向传播，不断调整模型权重以减小损失函数。
   • 监控训练过程：通过查看训练损失、验证集性能等，监控模型在训练过程中的表现。

6. 模型评估：

   • 使用验证集：在训练过程中，使用预留的验证集评估模型性能。调整模型结构和超参数，以提高模型的准确性和泛化能力。
   • 调整阈值：根据具体的应用需求，调整目标检测的阈值，以平衡准确率和召回率。

7. 模型保存与部署：

   • 保存模型权重：在满足性能要求后，保存训练好的模型权重。
   • 模型部署：将训练好的模型部署到实际应用中，可以是服务器端、嵌入式系统或移动端。

8. 测试与应用：

   • 使用测试数据：使用测试集验证模型在新数据上的性能。
   • 应用到实际场景：将训练好的模型应用到实际场景中，进行目标检测。

9. 维护与更新：

   • 模型监控：定期监控模型在实际应用中的性能，根据需要进行更新和调整。
   • 社区贡献：参与社区，了解最新的YOLO模型版本和优化，及时更新项目以保持最新性能。

具体操作

具体操作方法会取决于你选择的YOLO版本和深度学习框架。以下是一个基于YOLOv5和PyTorch的具体操作示例，供参考：

步骤：

1. 安装依赖：

   • 安装PyTorch：根据你的CUDA版本和操作系统选择合适的PyTorch版本，并按照PyTorch官方文档进行安装。
   • 安装其他依赖：运行 pip install -U -r requirements.txt 安装项目所需的其他依赖项。

2. 获取YOLOv5代码：

   • 克隆YOLOv5仓库：运行以下命令获取YOLOv5的代码。

     git clone https://github.com/ultralytics/yolov5.git
     cd yolov5
     1
     2

3. 数据准备：

   • 准备数据集：将你的目标检测数据集准备好，确保每个图像都有相应的标签文件，标签文件包含目标的类别、边界框坐标等信息。
   • 配置数据路径：在 data.yaml 文件中设置数据集的路径和类别信息。

4. 训练配置：

   • 修改训练配置：在 yolov5/models/yolov5s.yaml 中可以调整模型的参数，例如学习率、迭代次数等。
   • 准备预训练权重：下载并准备一个预训练权重文件，可以从YOLOv5的发布页面或其他来源获取。

5. 模型训练：

   • 运行训练命令：使用以下命令开始模型训练。

     python train.py --img-size 640 --batch-size 16 --epochs 50 --data data.yaml --cfg models/yolov5s.yaml --weights '' --name your_experiment_name
     1

   • 请根据实际情况调整命令中的参数。

6. 模型评估：

   • 运行测试命令：使用以下命令在验证集上评估模型性能。

     python test.py --weights runs/train/your_experiment_name/weights/best.pt --data data.yaml
     1

   • 检查评估指标，如Precision、Recall、mAP等。

7. 模型部署：

   • 保存权重：在训练结束后，你可以使用训练生成的权重文件进行推理。
   • 部署到实际应用：将模型集成到你的应用程序中，确保输入图像经过预处理后可以被模型识别。

详细实现

1. 安装依赖项：

确保你已经安装了Python，然后运行以下命令安装必要的依赖项：

pip install torch torchvision
pip install -U -r requirements.txt
1
2

2. 获取YOLOv5代码：

git clone https://github.com/ultralytics/yolov5.git
cd yolov5
1
2

3. 数据准备：

• 创建一个数据目录，将你的训练图像和标签文件（通常是.txt文件，每个文件对应一个图像）放入其中。
• 创建一个data.yaml文件，指定数据集的相关信息，例如类别数、训练集和验证集的路径等。

4. 配置训练：

• 打开 yolov5/models/yolov5s.yaml 文件，你可以调整模型的参数，如学习率、迭代次数等。此文件也包含有关锚框和类别的信息。

5. 准备预训练权重：

在YOLOv5的发布页面或官方仓库的 weights 目录中，你可以找到各种不同大小的预训练权重文件，选择一个合适的文件并下载。

6. 模型训练：

python train.py --img-size 640 --batch-size 16 --epochs 50 --data data.yaml --cfg models/yolov5s.yaml --weights 'path/to/your/pretrained_weights.pt' --name your_experiment_name
1

确保替换 path/to/your/pretrained_weights.pt 为你下载的预训练权重文件路径。

训练 状态结果.cvs

每轮训练指标

epoch: # 当前训练轮数
train/box_loss: # 训练阶段的边界框定位损失
train/obj_loss: # 训练阶段的目标对象损失
train/cls_loss: # 训练阶段的类别分类损失
metrics/precision: # 训练集上的精度指标
metrics/recall: # 训练集上的召回率指标
metrics/mAP_0.5: # 在IoU阈值为0.5时的平均精度（mAP）
metrics/mAP_0.5:0.95: # 在IoU阈值从0.5到0.95范围内的平均精度
val/box_loss: # 验证阶段的边界框定位损失
val/obj_loss: # 验证阶段的目标对象损失
val/cls_loss: # 验证阶段的类别分类损失
x/lr0: # 学习率调整，可能表示当前的学习率或学习率变化
x/lr1: # 另一个学习率变化点记录
x/lr2: # 第三个学习率变化点记录

训练过程信息

Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
2/2 0G 0.04473 0.07081 0.01642 250 640: 100%|██████████| 8/8 [02:19<00:00, 17.45s/it]

模型性能评估结果

             Class     Images  Instances          P          R      mAP50   mAP50-95: 100%|██████████| 4/4 [00:43<00:00, 10.92s/it]
               all        128        929      0.751      0.651      0.737      0.484
1
2

总结信息

3 epochs completed in 0.164 hours.
Optimizer stripped from runs\train\exp6\weights\last.pt, 14.9MB
Optimizer stripped from runs\train\exp6\weights\best.pt, 14.9MB
Validating runs\train\exp6\weights\best.pt…

模型融合及参数统计

Fusing layers…
Model summary: 157 layers, 7225885 parameters, 0 gradients, 16.4 GFLOPs

各类别详细评估结果

（略，包含每个类别的准确率、召回率以及mAP50和mAP50-95等指标）

结果保存路径

Results saved to runs\train\exp6

验证权重文件：Validating runs\train\exp6\weights\best.pt…
模型融合（优化性能）：Fusing layers…
模型结构概览：
层数：157层
参数数量：7,225,885个参数
当前梯度数量：0
计算量 (GFLOPs)：16.4
模型在不同类别上的评估指标汇总（包括精度P、召回率R、mAP50和mAP50-95等）：
总体表现：
图片总数：128张
实例总数：929个
精度（P）：0.752
召回率（R）：0.65
mAP@0.5：0.737
mAP@0.5:0.95：0.484
各类别详细评估结果，例如：
类别“person”：在128张图片中共有254个实例，其准确率为0.866，召回率为0.72，mAP@0.5为0.803，mAP@0.5:0.95为0.534
每个类别的详细评估结果显示了模型对各类目标的检测能力。

7. 模型评估：

python test.py --weights runs/train/your_experiment_name/weights/best.pt --data data.yaml
1

在这里，your_experiment_name 是你之前定义的实验名称。

8. 模型部署：

• 训练完成后，你可以使用 export.py 脚本将训练好的模型导出为TorchScript格式，以便更容易在其他环境中部署。

python export.py --img-size 640 --batch-size 1 --include pb  # 生成TorchScript模型
1

• 然后，可以将导出的模型集成到自己的应用程序中

大体过程

YOLOv5 使用的是一个基于卷积神经网络（CNN）的实时目标检测模型。YOLOv5 的模型结构继承了 YOLO 系列的特点，并在此基础上进行了优化和改进。

模型结构特点：

为什么这么快：

yolo中采用你只看一次的策略，简化了中间复杂的处理过程。

滑动窗口和YOLO（You Only Look Once）是两种不同的目标检测方法。

1. 滑动窗口传统算法：

   • 工作原理： 滑动窗口算法是一种传统的目标检测方法。它通过在图像上滑动一个固定大小的窗口，然后在每个窗口上应用分类器来判断是否包含目标。窗口的大小和步幅是预先定义的参数。
   • 优点： 简单直观，易于理解和实现。可以使用各种分类器，如SVM或神经网络。
   • 缺点： 需要在不同尺度和位置上尝试许多窗口，计算开销大。在多尺度情况下容易漏掉小目标，而且在大尺度上可能导致计算复杂度增加。

2. YOLO（You Only Look Once）：

   • 工作原理： YOLO是一种基于深度学习的目标检测算法。它将整个图像划分为固定大小的网格单元，并在每个单元格上预测目标的边界框和类别概率。YOLO在单个前向传递中同时完成了定位和分类，因此相对于滑动窗口方法，速度更快。
   • 优点： 高效，因为一次前向传递就可以获得整个图像中的目标信息。对于小目标和相互重叠的目标有较好的检测性能。
   • 缺点： 对于小目标的检测可能不如一些特定于小目标的方法。在处理密集目标布局时，可能存在定位精度较低的问题。

比较：

• 速度： YOLO通常比滑动窗口方法更快，因为它可以在整个图像上执行一次前向传递，而不是尝试多个窗口。
• 精度： YOLO在大目标和密集目标布局方面通常比滑动窗口方法更强大。但是，对于小目标，一些特定于小目标的方法可能会取得更好的效果。
• 计算复杂度： 滑动窗口方法的计算复杂度取决于尝试的窗口数量，而YOLO则在整个图像上进行一次前向传递，因此通常计算复杂度相对较低。

选择使用滑动窗口还是YOLO取决于具体的应用场景、性能需求和对目标检测的精度要求。

​ 比如滑动窗口传统算法

多尺度特征提取：

YOLOv5 采用 CSPDarknet 架构作为其主干网络，它结合了 Cross Stage Partial Network (CSPNet) 和 Darknet-53 的优点，以提高特征提取效率并减少计算量。
模型包含多个不同尺度的输出层，分别对应于小、中、大三种尺寸的目标检测。

Anchor Boxes：

继续使用锚框机制来预测目标框的位置和大小，每个网格单元会预测一组预先设定的锚框尺寸。

SPP（空间金字塔池化）模块：

在某些版本的 YOLOv5 中引入了 Spatial Pyramid Pooling 层，用于捕获多尺度信息。
PanopticFPN（全景特征金字塔网络）：
针对实例分割任务，YOLOv5x 版本引入了 PanopticFPN 来整合前景和背景的分割预测。

优化后的后处理步骤：

预测出的边界框经过非极大值抑制（NMS）进行过滤，保留高置信度且重叠较小的框。
对于边界框的坐标预测，YOLOv5 进行了坐标回归变换，比如使用 sigmoid 函数对中心偏移进行归一化处理，用指数函数对宽高进行缩放。

图形预测处理过程：

预处理阶段：

图像首先被调整到模型所需的输入尺寸（例如640×640），并进行标准化（减去均值、除以标准差）。
可能利用 CUDA 内核函数进行高效的图像缩放和色彩空间转换等操作。

模型推断阶段：

输入图片通过 CNN 进行前向传播，得到多个不同尺度的特征图。
每个特征图上的网格单元都会生成一系列边界框预测及其对应的类别概率和对象性得分。

解码预测结果：

将预测出的边界框偏移量、宽度高度调整参数以及类别的条件概率应用到对应的锚框上，从而得到最终预测的边界框位置和类别。
根据阈值筛选掉低置信度的边界框。
应用 NMS 删除冗余的预测框。

后处理：

输出最终经过 NMS 后筛选过的边界框以及它们的分类标签。
YOLOv5 在整个预测过程中高效地从输入图像中提取特征，预测目标的位置与类别，并通过一系列优化策略保证了模型在实时性与精度之间的平衡

win10下Pycharm运行代码配置

训练数据文件目录结构

训练文件相关参数修改

初次训练100次结果

“D:\Program Files\Python\Python38\python.exe” “D:\Program Files\JetBrains\PyCharm 2021.3\plugins\python\helpers\pydev\pydevconsole.py” --mode=client --port=50075
import sys; print(‘Python %s on %s’ % (sys.version, sys.platform))
sys.path.extend([‘E:\new work space\python\yolov5-master’, ‘E:/new work space/python/yolov5-master’])
PyDev console: starting.
Python 3.8.10 (tags/v3.8.10:3d8993a, May 3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)] on win32
runfile(‘E:/new work space/python/yolov5-master/trainTEST.py’, wdir=‘E:/new work space/python/yolov5-master’)
trainTEST: weights=yolov5s.pt, cfg=, data=data\coco128TEST.yaml, hyp=data\hyps\hyp.scratch-low.yaml, epochs=100, batch_size=16, imgsz=640, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, evolve_population=data\hyps, resume_evolve=None, bucket=, cache=None, image_weights=False, device=, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=8, project=runs\train, name=exp, exist_ok=False, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, seed=0, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest, ndjson_console=False, ndjson_file=False
github: skipping check (not a git repository), for updates see https://github.com/ultralytics/yolov5
YOLOv5 2024-1-9 Python-3.8.10 torch-2.1.2+cpu CPU
hyperparameters: lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0
Comet: run ‘pip install comet_ml’ to automatically track and visualize YOLOv5 runs in Comet
TensorBoard: Start with ‘tensorboard --logdir runs\train’, view at http://localhost:6006/
Overriding model.yaml nc=80 with nc=12
from n params module arguments
0 -1 1 3520 models.common.Conv [3, 32, 6, 2, 2]
1 -1 1 18560 models.common.Conv [32, 64, 3, 2]
2 -1 1 18816 models.common.C3 [64, 64, 1]
3 -1 1 73984 models.common.Conv [64, 128, 3, 2]
4 -1 2 115712 models.common.C3 [128, 128, 2]
5 -1 1 295424 models.common.Conv [128, 256, 3, 2]
6 -1 3 625152 models.common.C3 [256, 256, 3]
7 -1 1 1180672 models.common.Conv [256, 512, 3, 2]
8 -1 1 1182720 models.common.C3 [512, 512, 1]
9 -1 1 656896 models.common.SPPF [512, 512, 5]
10 -1 1 131584 models.common.Conv [512, 256, 1, 1]
11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, ‘nearest’]
12 [-1, 6] 1 0 models.common.Concat [1]
13 -1 1 361984 models.common.C3 [512, 256, 1, False]
14 -1 1 33024 models.common.Conv [256, 128, 1, 1]
15 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, ‘nearest’]
16 [-1, 4] 1 0 models.common.Concat [1]
17 -1 1 90880 models.common.C3 [256, 128, 1, False]
18 -1 1 147712 models.common.Conv [128, 128, 3, 2]
19 [-1, 14] 1 0 models.common.Concat [1]
20 -1 1 296448 models.common.C3 [256, 256, 1, False]
21 -1 1 590336 models.common.Conv [256, 256, 3, 2]
22 [-1, 10] 1 0 models.common.Concat [1]
23 -1 1 1182720 models.common.C3 [512, 512, 1, False]
24 [17, 20, 23] 1 45849 models.yolo.Detect [12, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]
Model summary: 214 layers, 7051993 parameters, 7051993 gradients, 16.0 GFLOPs
Transferred 343/349 items from yolov5s.pt
optimizer: SGD(lr=0.01) with parameter groups 57 weight(decay=0.0), 60 weight(decay=0.0005), 60 bias
train: Scanning E:\new work space\python\datasets\coco128Test\labels\train2017.cache… 44 images, 0 backgrounds, 0 corrupt: 100%|██████████| 44/44 [00:00<?, ?it/s]
val: Scanning E:\new work space\python\datasets\coco128Test\labels\train2017.cache… 44 images, 0 backgrounds, 0 corrupt: 100%|██████████| 44/44 [00:00<?, ?it/s]
AutoAnchor: 3.99 anchors/target, 1.000 Best Possible Recall (BPR). Current anchors are a good fit to dataset
Plotting labels to runs\train\exp9\labels.jpg…
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to runs\train\exp9
Starting training for 100 epochs…
Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
0/99 0G 0.123 0.03793 0.07844 66 640: 100%|██████████| 3/3 [01:20<00:00, 26.87s/it]
Class Images Instances P R mAP50 mAP50-95: 0%| | 0/2 [00:00<?, ?it/s]WARNING NMS time limit 2.100s exceeded
Class Images Instances P R mAP50 mAP50-95: 50%|█████ | 1/2 [00:14<00:14, 14.95s/it]WARNING NMS time limit 1.100s exceeded
Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:20<00:00, 10.26s/it]
all 44 117 0 0 0 0

​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 17/99 0G 0.07482 0.03235 0.03232 47 640: 100%|██████████| 3/3 [00:55<00:00, 18.60s/it]
​ Class Images Instances P R mAP50 mAP50-95: 50%|█████ | 1/2 [00:13<00:13, 13.55s/it]WARNING NMS time limit 1.100s exceeded
​ Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:18<00:00, 9.34s/it]
​ all 44 117 0.276 0.341 0.302 0.129
​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 36/99 0G 0.07347 0.02879 0.01845 86 640: 100%|██████████| 3/3 [00:45<00:00, 15.21s/it]
​ Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:17<00:00, 8.51s/it]
​ all 44 117 0.454 0.625 0.432 0.197
​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 69/99 0G 0.04048 0.02377 0.01117 80 640: 100%|██████████| 3/3 [00:48<00:00, 16.22s/it]
​ Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:16<00:00, 8.01s/it]
​ all 44 117 0.772 0.82 0.93 0.666
​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 80/99 0G 0.03914 0.0196 0.01344 64 640: 100%|██████████| 3/3 [00:48<00:00, 16.22s/it]
​
​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 90/99 0G 0.03442 0.02564 0.008466 58 640: 100%|██████████| 3/3 [00:52<00:00, 17.55s/it]
​ Epoch GPU_mem box_loss obj_loss cls_loss Instances Size
​ 99/99 0G 0.036 0.02346 0.009882 74 640: 100%|██████████| 3/3 [00:51<00:00, 17.20s/it]
​ Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:16<00:00, 8.26s/it]
​ all 44 117 0.762 0.918 0.934 0.699
100 epochs completed in 1.932 hours.
Optimizer stripped from runs\train\exp9\weights\last.pt, 14.5MB
Optimizer stripped from runs\train\exp9\weights\best.pt, 14.5MB
Validating runs\train\exp9\weights\best.pt…
Fusing layers…
Model summary: 157 layers, 7042489 parameters, 0 gradients, 15.9 GFLOPs
​ Class Images Instances P R mAP50 mAP50-95: 100%|██████████| 2/2 [00:14<00:00, 7.50s/it]
​ all 44 117 0.766 0.94 0.935 0.708
​ person 44 18 0.601 0.778 0.81 0.387
​ apple 44 40 0.858 1 0.994 0.757
​ banana 44 2 0.903 1 0.995 0.846
​ zebra 44 6 0.915 1 0.995 0.747
​ car 44 23 0.457 0.957 0.887 0.524
​ bus 44 7 0.862 0.857 0.857 0.743
​ long 44 4 0.897 1 0.995 0.796
​ cat 44 3 0.67 1 0.913 0.797
​ dog 44 4 0.616 0.809 0.912 0.705
​ hourse 44 10 0.88 1 0.995 0.782
Results saved to runs\train\ex

训练过程评估 一些参数的含义

模型在验证集上的mAP以及损失函数的表现会作为衡量模型性能好坏的主要依据。而学习率则是调整模型训练过程的关键参数。

使用训练好的参数进行进项预测处理数据

用训练集数据验证的结果

 | 0.76249           | 0.91764                                                      | 0.93402                                                      | 0.69939                                         | 0.029954                                                     | 0.012428           | 0.0056608          | 0.000298                                                    | 0.000298                                                  | 0.000298                                                     |
1

模型在验证集上的mAP以及损失函数的表现会作为衡量模型性能好坏的主要依据。而学习率则是调整模型训练过程的关键参数。

使用训练好的参数进行进项预测处理数据

使用自己的权重文件预测

用训练集数据验证的结果