我自己的原文哦~  https://blog.51cto.com/whaosoft/12512597

1、Yolo8

1.1、检测PCB元件

  技术世界正在以惊人的速度发展，而这种转变的核心是一个革命性的工具 — 计算机视觉。它最有趣的应用之一是电子印刷电路板 （PCB） 的检测和分析。本文探讨了使用计算机视觉进行电子 PCB 检测的令人兴奋的可能性和潜在的工业应用。

    在深入研究计算机视觉在 PCB 检测中的开创性应用之前，必须了解什么是 PCB 以及为什么它们在我们这个技术驱动的世界中至关重要。

什么是 PCB？

    PCB 或印刷电路板是几乎所有电子设备的基本组件。它是连接各种电子元件的中央平台。PCB 设计有复杂的导电走线、焊盘和通孔图案，可实现元件之间的电信号流动。它们本质上是现代电子产品的神经系统。

    PCB 由许多组件组成，每个组件都有其特定的功能。一些基本组件包括：

• 微控制器和微处理器：这些是许多电子设备背后的脑力，用于执行编程任务。
• 电阻器和电容器：它们分别调节电流的流动和储存能量。
• 晶体管和二极管：这些半导体器件控制电流并实现信号放大或整流。
• 连接：这些支持与设备的外部连接，例如 USB 端口和 HDMI 连接器。
• 集成电路 （IC）：IC 在单个芯片上包含复杂的电路，执行各种功能，如信号处理、内存存储等。
• 指示灯：发光二极管用于视觉指示和显示。

计算机视觉在 PCB 检测中的强大功能

    现在，让我们探索计算机视觉在 PCB 检测和分析中的开创性潜力：

• 组件标识：计算机视觉算法可以精确识别和分类 PCB 上的组件。这包括识别元件类型（电阻器、电容器、IC 等），甚至读取零件编号或标签。
• 质量管理：在电子制造等行业中，计算机视觉可用于质量控制。它可以检测制造缺陷，例如焊接问题、缺少组件或放置不正确。
• 维护和维修：在维护和维修场景中，计算机视觉可以帮助技术人员快速识别故障组件。这减少了停机时间并确保了高效的维修。
• 定制 PCB 设计：计算机视觉可以通过分析布局并提出改进建议以获得更好的性能和可靠性来协助 PCB 的定制设计。
• 假冒检测：随着假冒电子元件的兴起，计算机视觉可用于检测假冒或不合格的零件，确保产品的真伪。
• 自动检测：在高速生产线中，计算机视觉可以自动化检测过程，显著提高吞吐量并减少人为错误。

工业应用

    使用计算机视觉进行电子 PCB 检测的应用延伸到各个行业：

• 电子制造：简化生产流程，改善质量控制，并降低生产成本。
• 汽车：确保车辆电子系统的可靠性，提高安全性和性能。
• 航空 航天：对于航空电子系统的可靠性和安全性至关重要，其中精度至关重要。
• 消费电子产品：提高产品质量并加快智能手机、平板电脑和笔记本电脑等设备的上市时间。
• 医疗设备：确保医疗设备的精度和可靠性，降低故障风险。
• 电信：保证通信基础设施中电子元件的质量和功能。
• 国防和安全：对于国防和安全应用中使用的电子系统的完整性和可靠性至关重要。

YOLO 工作流程

• 输入图像：YOLO 将图像作为其输入。此图像可以是从照片到医学扫描或视频帧的任何内容。
• 卷积神经网络 （CNN）：输入图像通过深度卷积神经网络 （CNN） 进行处理。这个 CNN 在特征提取和理解图像内容方面起着至关重要的作用。
• 网格划分：YOLO 将处理后的图像划分为网格。此网格中的每个单元格都负责对其边界内存在的对象进行预测。这种基于网格的方法可实现高效的本地化对象检测。
• 边界框：在每个网格单元格中，YOLO 预测将对象紧密包围的边界框（矩形）。这些边界框指定检测到的对象的位置和大小。
• 类预测：同时，YOLO 会预测边界框内包含的每个对象的类。例如，在医学成像中，它可能会预测物体是骨折、关节还是正常组织。
• 置信度分数：YOLO 为每个预测的边界框分配置信度分数。这些分数表示模型对预测准确性的置信度。高置信度分数表示边界框包含有效对象的可能性很高。
• Non-Maximum Suppression（非极大值抑制）：为了优化结果并消除重复或重叠的预测，YOLO 采用了一种称为非极大值抑制的技术。此步骤可确保仅保留最准确和最相关的预测
• 输出：YOLO 的最终输出包括边界框、其关联的对象类和置信度分数。这些结果提供了对输入图像中检测到的对象的全面了解。

    Roboflow PCB 数据集：

https://universe.roboflow.com/search?q=pcb

# replace with your own api key
#visit the above roboflow dataset liunk and download dataset section and 
#try download code for yolov8 copy paste that
#dont copy pasrte this my api key shouldnt work for you..privacy!pip install roboflow
from roboflow import Roboflow
rf = Roboflow(api_key="****************")
project = rf.workspace("tcc-hugo").project("PCBr")
dataset = project.version(2).download("yolov8")
!pip install ultralytics
from ultralytics import YOLO
model = YOLO('yolov8n.pt')
model.train(data='/content/data.yaml',epochs=70) 
#paste path properly in ur colab of data.yaml

先决条件

    在 Pycharm 或 Vscode 中使用本地自定义训练 best.pt

!pip install ultralytics
from ultralytics import YOLO
model=YOLO("best.pt") 
#download fron runs/detect/train/weights/best.pt supoose trained in GColab
results=model(source="Video.mp4",save=True,cnotallow=0.4)

使用计算机视觉进行 PCB 检测的挑战和进展

    虽然使用计算机视觉进行 PCB 检测的潜在好处是巨大的，但也有一些重大挑战需要克服。然而，技术的进步正在解决其中的许多问题：

• 小型化：随着电子元件变得越来越小，PCB 上的封装密度越来越大，准确检测和识别它们的挑战也随之增加。计算机视觉算法在处理小型化组件的能力方面不断提高。
• 不同的组件形状和尺寸：PCB 上的组件有不同的形状和尺寸，这使得开发一个放之四海而皆准的计算机视觉系统具有挑战性。机器学习技术（包括深度学习）正被用于开发适应性强的算法。
• 复杂的 PCB 设计：现代 PCB 通常采用复杂的多层设计，两侧都有组件。计算机视觉系统正在不断发展，以处理这些复杂性并提供准确的分析。
• 实时处理：在实时处理至关重要的行业中，例如机器人或自动驾驶汽车，计算机视觉系统需要以最小的延迟运行。图形处理单元 （GPU） 和现场可编程门阵列 （FPGA） 等专用硬件用于加速处理。
• 照明条件：适当的照明对于准确的图像捕获和分析至关重要。照明技术的进步和多光源的使用有助于克服与照明变化相关的问题。

PCB 检测在工业中的进一步应用

• 库存管理：计算机视觉可以通过跟踪库存组件的数量和类型来自动化电子制造中的库存管理。
• 预测性维护：通过持续监测 PCB 及其组件的状况，预测性维护系统可以预测组件何时可能发生故障，从而及时更换并减少停机时间。
• 回收和电子废物管理：计算机视觉可用于回收设施，以识别和分离电子元件与废物，从而促进可持续实践。
• 安全和身份验证：PCB 检测可用于安全目的，例如识别对电子设备的篡改或未经授权的修改。
• 教育与培训：基于计算机视觉的教育工具可以帮助学生和专业人士以互动和引人入胜的方式了解 PCB 设计和组件。
• 定制电子产品：企业家和业余爱好者可以利用 PCB 检测技术来设计和制作用于各种用途的定制电子产品的原型。

1.2、药丸/片剂类型识别

药丸鉴定问题

    想象一下这个场景：你手里有一颗药丸，但你不太确定它是什么。也许标签已经磨损，或者您在药柜中发现它松动了。正确识别药物对您的安全和健康至关重要。这就是计算机视觉的用武之地。

    药丸识别的工作原理

• 图像捕获：要开始识别过程，您需要使用智能手机或专用设备为药丸拍摄清晰的照片。照明和角度会影响识别的准确性，因此捕获高质量的图像至关重要。
• 图像预处理：获得图像后，将使用计算机视觉算法对其进行预处理。这涉及降噪、对比度增强和图像大小调整等任务，以确保为分析提供最佳输入。
• 特征提取：下一步是从图像中提取特征。特征可能包括药丸的形状、颜色、标记和任何唯一标识符。
• 模式识别：然后，计算机视觉模型分析这些特征，并将它们与已知药物的庞大数据库进行比较。该数据库包含有关各种药丸的外观、标记和特征的信息。
• 分类：根据比较，系统会对药丸进行分类，并为您提供其名称、剂量和其他相关信息。

YOLO 工作流程

• 输入图像：YOLO 将图像作为其输入。此图像可以是从照片到医学扫描或视频帧的任何内容。
• 卷积神经网络 （CNN）：输入图像通过深度卷积神经网络 （CNN） 进行处理。这个 CNN 在特征提取和理解图像内容方面起着至关重要的作用。
• 网格划分：YOLO 将处理后的图像划分为网格。此网格中的每个单元格都负责对其边界内存在的对象进行预测。这种基于网格的方法可实现高效的本地化对象检测。
• 边界框：在每个网格单元格中，YOLO 预测将对象紧密包围的边界框（矩形）。这些边界框指定检测到的对象的位置和大小。
• 类预测：同时，YOLO 会预测边界框内包含的每个对象的类。例如，在医学成像中，它可能会预测物体是骨折、关节还是正常组织。
• 置信度分数：YOLO 为每个预测的边界框分配置信度分数。这些分数表示模型对预测准确性的置信度。高置信度分数表示边界框包含有效对象的可能性很高。
• Non-Maximum Suppression（非极大值抑制）：为了优化结果并消除重复或重叠的预测，YOLO 采用了一种称为非极大值抑制的技术。此步骤可确保仅保留最准确和最相关的预测
• 输出：YOLO 的最终输出包括边界框、其关联的对象类和置信度分数。这些结果提供了对输入图像中检测到的对象的全面了解。

    Roboflow Pill 分类数据集：

https://universe.roboflow.com/drug1-dr14z/drug-swwtp

# replace with your own api key
#visit the above roboflow dataset liunk and download dataset section and 
#try download code for yolov8 copy paste that
#dont copy pasrte this my api key shouldnt work for you..privacy!pip install roboflowfrom roboflow import Roboflow
rf = Roboflow(api_key="your api key here")
project = rf.workspace("drug1-dr14z").project("drug-swwtp")
dataset = project.version(1).download("yolov8")!pip install ultralytics
from ultralytics import YOLO
model = YOLO('yolov8n.pt')
model.train(data='/content//data.yaml',epochs=70) 
#paste path properly in ur colab of data.yaml

    在 Pycharm 或 Vscode 中使用本地自定义训练 best.pt

!pip install ultralytics
from ultralytics import YOLO
model=YOLO("best.pt") 
#download fron runs/detect/train/weights/best.pt supoose trained in GColab
results=model(source="PillVideo.mp4",save=True,cnotallow=0.4)

    使用计算机视觉进行片剂/药丸类型名称检测的好处

• 安全：准确的药丸识别对于避免用药错误至关重要，尤其是对于那些服用多种药物的人。
• 可及性：这项技术使任何拥有智能手机或支持摄像头的设备的人都可以进行药丸识别。
• 速度：计算机视觉算法可以在几秒钟内识别药丸，从而快速提供结果。
• 医疗保健援助：医疗保健专业人员可以使用这项技术来验证处方并改善患者护理。

1.3、高级目标检测和区域计数

 这需要识别和精确定位图像或视频中的物体。在此基础上，使用 Ultralytics YOLOv8 进行基于区域的物体计数可通过量化指定区域中的物体来增强物体检测。此类进步具有变革性的应用，从准确计算城市人行横道上的行人到通过计算货架上的产品来完善库存管理。

    利用 YOLOv8 进行对象计数不仅可以推动业务走向自动化，还可以改善安全措施和数据驱动的决策。

    本文主要介绍以下内容：

• 多区域物体计数的特点
• 真实用例

多区域物体计数的特点

    对象计数可统计视频或图像中的对象。另一方面，基于区域的计数侧重于计数特定区域内的对象。YOLOv8 的区域计数将重点转移到帧内的特定指定区域。它不只是计数；它还涉及正确计数，以及计数重要的地方。此模块配备了几个功能：

    可移动区域：设置区域坐标并启动 YOLOv8 区域计数模块的推理后 ，YOLOv8 允许实时调整，这意味着无需深入编辑代码即可即时重新定位区域。此外，对于那些不太懂技术的人来说，只需拖动鼠标即可。

    多种形式的区域：从矩形到复杂的多边形，区域可以根据不同的计数场景进行定制。

    实时性能：YOLOv8 已经建立了实时性能的声誉，加入区域计数模块不会影响 YOLOv8 的实时能力。

    Ultralytics社区支持：在 Ultralytics，我们致力于帮助用户成功使用 YOLOv8。 

Ultralytics YOLOv8 基于区域的计数的实际应用

    在指定区域内进行物体计数的应用有很多，我们将通过附带的视觉示例重点介绍其中的三种应用。

    零售 — 客流统计

    零售店主使用工具来跟踪店内每日客流量，从而优化客户体验和收入来源。统计人数的应用程序可以提供有价值的数据。此外，能够专注于特定的商店区域可以提供更精确的洞察，这就是 YOLOv8 区域计数派上用场的地方。

    库存管理——货架产品计数

    YOLOv8 区域计数模块提供了一种高效而直接的方法来计数商店指定区域的产品。尤其是在产品展示位置每 2-3 周就会发生变化的动态零售环境中，此工具脱颖而出。它允许实时调整，确保库存数量保持准确并反映货架上的实际库存。这不仅有助于补货决策，还可以提高整体商店效率。

    体育分析——球员计数

    借助 YOLOv8 区域计数，体育分析师可以准确跟踪特定区域内的球员。这项技术不仅可以统计球员数量，还可以将这些数据输入综合分析，从而更深入地了解球员的行为和策略。

1.4、停车对齐检测

 检查对象的对齐方式包括确保它正好位于需要的位置以及正确的位置和方向。对象的对齐和位置可能需要在各个领域中具有高水平的精度。例如，在制造过程中，即使是很小的不对中也会导致缺陷。同样，在机器人技术中，拾取物体等任务需要精确定位。

    自动检查对象对齐的一种高级方法是使用计算机视觉。计算机视觉系统可以捕获图像或视频帧，并使用深度学习算法准确检测和分析物体的位置和方向。

    在本文中，我们将探讨使用计算机视觉检测对齐的方法，包括其工作原理、传统技术和实际应用。

了解对象对齐

    对象对齐可以分为两种主要类型：2D 对齐和 3D 对齐。2D 对齐侧重于将对象正确定位在平面上或二维平面内。这是为了确保对象相对于水平轴和垂直轴的正确方向，而不是从其预期位置倾斜或移动。2D 对齐的常见用途是图像拼接，其中将多个图像组合在一起以创建单个无缝全景图。

    另一方面，3D 对齐处理在三维空间中定位对象。这更棘手，因为它还会检查对象是否沿 z 轴正确定向。点云配准等技术在这里发挥作用，并且经常使用迭代最近点 （ICP） 算法。它有助于对齐从不同角度捕获的 3D 模型或点云（3D 空间中数据点的集合）。3D 对齐通常用于机器人技术中，用于精确导航和处理对象。它还用于 3D 重建，以创建物体或场景的详细模型。

传统的比对检测技术​

    过去，传统的图像分析方法被广泛用于检测物体的对齐情况。这些技术在今天仍然很重要，并且是许多现代计算机视觉技术的构建块。让我们来看看三个关键的传统技术：边缘检测、特征匹配和参考标记。

    边缘检测可以帮助您在图像中查找对象的边界或边缘。通过识别这些边缘，您可以确定对象相对于其他对象的位置或对齐方式。当对象具有清晰、锐利的边缘时，此方法效果很好。但是，当条件不完美时，这可能会很棘手。例如，当光线不足时，会出现杂色，或者对象的一部分被隐藏。一种用于边缘检测的流行算法是 Canny Edge Detection。在检测之前应用高斯模糊等技术或使用 Otsu 阈值等自适应方法有助于提高边缘检测的准确性。

    特征匹配涉及比较不同图像之间的特定细节或关键点以检查对齐情况。它会在一张图像中寻找独特的特征，并尝试将它们与另一张图像中的相似特征相匹配。但是，当对象没有强烈、独特的特征，或者图像之间的比例、旋转或照明发生很大变化时，这可能具有挑战性。Scale-Invariant Feature Transform （SIFT） 和加速稳健特征 （SURF） 等常用方法通常用于特征匹配，尽管它们在恶劣条件下可能会有局限性。

    参考标记是框架中的固定点或特征，用作测量对象对齐方式的锚点。当您需要准确且可重复的测量时，例如在 3D 计量中，这些标记特别有用。通过将这些标记放置在已知位置，您可以准确确定对象在 3D 空间中的位置、方向和缩放。

使用计算机视觉检测对齐的方法​

    计算机视觉可以使检测和测量物体的对齐变得更加简单。借助先进的算法和机器学习，我们可以准确确定物体在 2D 和 3D 空间中的方向、角度和位置。让我们探讨一下用于检测对齐的三种关键方法：对象方向检测、角度测量和姿态估计。

    对象方向检测侧重于识别边缘和角落等关键特征，以了解对象的方向。这里使用的常用技术是主成分分析 （PCA）。PCA 通过简化图像数据和突出显示最重要的特征来提供帮助。它找到数据变化的主要方向（称为特征向量），并使用它们来确定对象的定向方式。例如，PCA 可以分析像素强度在图像中的分布情况，以创建更准确地反映对象真实位置的新轴。

    确定物体的方向后，可以使用角度测量。可以计算检测到的方向与参考线之间的角度。在即使是很小的不对中也会导致问题的情况下，它非常方便。

    姿势估计是一种更高级的技术，用于确定对象在 3D （3D） 空间中的方向和位置。它通常首先使用深度学习技术，例如卷积神经网络 （CNN），从图像中提取关键特征。然后，这些特征用于计算对象相对于照相机或观察点的 3D 方向和位置。数学模型（如透视 n 点 （PnP） 算法）有助于将图像中的 2D 点连接到相应的 3D 坐标。

    除了对象方向检测、角度测量和姿势估计等方法外，您还可以使用对象检测和逻辑检查等更简单的方法来确定对齐方式。例如，您可以在图像或空间内设置预定义区域，并检查检测到的对象是否正确放置在这些区域内。在下一节中，我们将仔细研究其工作原理。

检测对象对齐：具体步骤

    在此示例中，我们将演练使用计算机视觉检测对象对齐的过程。我们将要介绍的代码旨在检测和检查对象是否落在指定的多边形区域内。我们将使用这种方法来查看汽车是否正确停放在其位置内，方法是将停车位定义为面，并确保检测到的车辆完全位于这些区域内。

    要自己尝试此操作，您需要一个图像来运行推理。我们使用了从 Internet 下载的图像。您可以使用同一图像，也可以使用自己的图像。让我们开始吧！

    步骤 #1：安装必要的库并加载模型

    首先，确保您已安装必要的 Python 库。我们将使用推理等库进行模型加载，使用 opencv 进行图像处理，并使用监督来处理检测和注释。

    首先，安装推理库。

pip install inference

    接下来，导入必要的库：

import numpy as np
import supervision as sv
import cv2
import inference

接下来，我们可以加载一个 YOLOv8 模型：

model = inference.get_model("yolov8x-640")

    步骤 #2：加载图像并运行推理

    加载输入图像并使用 YOLOv8 模型检测其中的对象：

image = cv2.imread("path/to/image/file")
results = model.infer(image)[0]
detections = sv.Detections.from_inference(results)

    在这里，图像是使用 OpenCV 的 imread 函数加载的。然后，模型处理图像，并将结果转换为监督可用于管理检测的格式。

    步骤 #3：为区域定义多边形

    在此步骤中，我们定义了几个多边形，每个多边形都由一个坐标列表表示。这些多边形至关重要，因为它们定义了将检查对象对齐的区域。您可以使用 PolygonZone 创建这些多边形，该工具允许您在图像上绘制多边形并检索坐标。在此博客文章中了解有关如何使用它的更多信息。

    以下代码片段定义了表示要检查对齐的区域的多边形。

polygons = [np.array([[67, 416], [141, 416], [141, 273], [67, 278]]),np.array([[140, 416], [208, 416], [208, 279], [135, 275]]),...# Add more polygons as needed
]

    步骤 #4：创建多边形区域和注释器

    定义多边形后，我们现在可以创建区域和相应的注释器。我们创建一个 PolygonZone 对象列表，每个对象都与其中一个多边形相关联。triggering_anchors 参数设置为检查对象的所有四个角，确保它们位于定义的区域内。PolygonZone 类是定义这些区域的有用工具，它让我们可以轻松检查检测到的对象是否在这些区域内对齐。

zones = [sv.PolygonZone(polygon=polygon,triggering_anchors=(sv.Position.TOP_LEFT,sv.Position.TOP_RIGHT,sv.Position.BOTTOM_LEFT,sv.Position.BOTTOM_RIGHT),)for polygon in polygons
]

    接下来，我们创建注释器以直观地标记这些区域和检测到的对象。PolygonZoneAnnotator 和 BoxAnnotator 有助于将视觉元素添加到输出图像中。这些注释器将绘制多边形和边界框，并可以轻松查看对象的位置以及它们是否正确对齐。

zone_annotators = [sv.PolygonZoneAnnotator(zone=zone,color=colors.by_idx(index),thickness=2,text_thickness=1,text_scale=1)for index, zonein enumerate(zones)
]box_annotators = [sv.BoxAnnotator(color=colors.by_idx(index),thickness=2)for indexin range(len(polygons))
]

    步骤 #5：应用注释并显示结果

    最后，我们可以筛选检测结果，使其仅包含定义区域内的检测结果，应用注释并显示结果图像。

for zone, zone_annotator, box_annotator in zip(zones, zone_annotators, box_annotators):mask = zone.trigger(detections=detections)detections_filtered = detections[mask]frame = box_annotator.annotate(scene=image, detections=detections_filtered)frame = zone_annotator.annotate(scene=frame)sv.plot_image(frame, (8, 8))

    这是输出图像。如您所见，标记为“0”的停车位有未正确对齐的车辆，而标记为“1”的停车位有车辆对齐并正确停放其中。

挑战和注意事项

    使用计算机视觉检测对象对齐是一个强大的工具，但它也带来了一系列挑战。以下是一些关键挑战：

• 复杂对象的精度较低：具有不寻常形状或复杂设计的对象有时会混淆检测算法并导致对齐错误。纹理、颜色或表面条件的变化也会使算法更难一致地正确识别和对齐对象。
• 处理异常情况：算法可能会遇到困难，处理罕见或不寻常的情况，通常称为“边缘情况”，并且可能需要更多的训练数据来有效处理这些情况。
• 环境因素：光照的变化会产生阴影或高光，从而掩盖重要细节，并使对齐更难准确检测。繁忙或杂乱的背景也会混淆检测算法，而反光或透明表面可能会扭曲对象的外观并使过程复杂化。
• 实时处理：当需要实时进行对齐检测时，例如在装配线上，系统必须处理图像并快速做出决策。实时处理可能需要更昂贵的硬件来支持所需的处理能力。
• 集成挑战：将计算机视觉系统与现有机器和工作流程集成可能很复杂，需要仔细规划以确保一切顺利进行。

2、Yolo11

2.1、如何使用 YOLOv11 分割对象

在快速发展的计算机视觉领域，YOLO 模型一直在不断突破实时物体检测和分割的界限。从最早的迭代开始，YOLO 就改变了机器解读视觉数据的方式，优先考虑速度和准确性。现在，借助 YOLOv11，我们看到性能和功能有了显著的飞跃，尤其是在物体分割方面——这是一项关键技术，它不仅能让我们检测物体，还能让我们在图像中区分物体的确切边界。

    在之前的博客中，我探讨了如何使用YOLOv8和YOLOv9实现对象分割，并讨论了每个版本为该领域带来的改进。YOLOv11 在此基础上构建，具有增强的神经架构和优化的分割功能，可提供更准确、更高效的对象描绘。这使得它对于自动驾驶、医学成像和实时监控等应用特别有价值，在这些应用中，了解物体的形状和大小与简单地检测它们一样重要。

    与单纯的检测不同，对象分割是指了解对象的确切空间属性，使我们能够将图像划分为有意义的区域。YOLOv11 使用高级卷积层和创新的主干网络来提供更清晰、更准确的对象边界，即使在复杂或混乱的场景中也是如此。在这篇博客中，我将向您展示 YOLOv11 如何改进分割任务，并概述在您自己的项目中实现它的步骤。

如何使用 YOLOv11 分割图像

    步骤1：安装必要的库

pip install opencv-python ultralytics numpy

    步骤2：导入库

from ultralytics import YOLO
import random
import cv2
import numpy as np

    步骤3：选择模型

model = YOLO("yolo11m-seg.pt")

    下载链接：

https://docs.ultralytics.com/tasks/segment/#models

    步骤4：使用 YOLOv11 分割图像中的对象

img = cv2.imread( "YourImagePath" ) # 如果你想要所有的类
yolo_classes = list (model.names.values()) 
classes_ids = [yolo_classes.index(clas) for clas in yolo_classes] 
conf = 0.2results = model.predict(img, cnotallow=conf) 
colors = [random.choices( range ( 256 ), k= 3 ) for _ in classes_ids] 
print (results) 
for result in results: for mask, box in  zip (result.masks.xy, result.boxes): points = np.int32([mask]) color_number = classes_ids.index( int (box.cls[ 0 ])) cv2.fillPoly(img, points, colors[color_number])

    1.加载图像：

    img = cv2.imread("YourImagePath")使用OpenCV的函数从指定路径读取图像cv2.imread()。

    2. 预测准备：

    yolo_classes = list(model.names.values())创建YOLOv11模型识别的类名列表。

    classes_ids = [yolo_classes.index(clas) for clas in yolo_classes]创建与这些名称对应的类 ID 列表。

    conf = 0.2设置对象检测的置信度阈值。只有置信度分数高于此阈值的预测才会被考虑。

    3.运行模型预测：

    results = model.predict(img, cnotallow=conf)调用predict()YOLOv11 模型的方法对加载的图像进行预测。结果包括检测到的物体、其边界框、掩码（多边形轮廓）、置信度分数和类别预测。

    colors = [random.choices(range(256), k=3) for _ in classes_ids]生成一个随机颜色列表，每个类别一个，用于视觉表示。

    4. 处理结果和可视化蒙版：

    循环for遍历结果中每个检测到的对象：

    mask, box = zip(result.masks.xy, result.boxes)解压对象的掩码坐标和边界框信息。

    points = np.int32([mask])将掩码坐标（可能是浮点格式）转换为整数，以便使用 OpenCV 在图像上绘制。

    color_number = classes_ids.index(int(box.cls[0]))根据对象的预测类别确定视觉表示的颜色索引。

    cv2.fillPoly(img, points, colors[color_number])使用原始图像上的相应颜色填充蒙版坐标定义的多边形，有效地创建对象的视觉分割。

    步骤5：保存并绘制结果图像

cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.imwrite("YourSavePath", img)

    完整代码：

from ultralytics import YOLO
import random
import cv2
import numpy as npmodel = YOLO("yolo11m-seg.pt") img = cv2.imread("00.jpg")# if you want all classes
yolo_classes = list(model.names.values())
classes_ids = [yolo_classes.index(clas) for clas in yolo_classes]conf = 0.2results = model.predict(img, cnotallow=conf)
colors = [random.choices(range(256), k=3) for _ in classes_ids]for result in results:for mask, box in zip(result.masks.xy, result.boxes):points = np.int32([mask])color_number = classes_ids.index(int(box.cls[0]))cv2.fillPoly(img, points, colors[color_number])cv2.imshow("Image", img)
cv2.waitKey(0)cv2.imwrite("res.jpg", img)

2.2、车体部件检测与分割

YOLOv11 有哪些新功能？

    YOLOv11 在 YOLOv10 的基础上进行了重大升级，在性能和适应性方面有了显著的提高。主要增强功能包括：

    1. 改进的模型架构：YOLOv11 引入了更高效的模型架构，旨在优化图像处理和预测准确性。

    2. GPU 优化：利用现代机器学习的进步，YOLOv11 针对 GPU 训练进行了高度优化，可提供更快的模型训练和更高的准确性。

    3. 速度提升：YOLOv11 模型的延迟降低了 25%，比之前的版本快得多。速度提升增强了实时性能。

    4. 更少的参数，相同的精度：简化的架构可减少参数，从而无需牺牲模型的精度即可实现更快的处理速度。

    5. 增强适应性和任务支持：YOLOv11 支持更广泛的任务、对象类型和图像格式，扩展了其多功能性并使其适用于更加多样化的应用。

    通过这些增强功能，YOLOv11 为物体检测设立了新的标准，在不牺牲准确性的情况下提供更快、更高效的模型。

YOLOv11 包含哪些模型？

    YOLOv11 提供了多种针对各种任务而设计的模型。这些包括：

    1. 边界框模型：用于检测图像中对象的标准 YOLOv11 模型，没有任何后缀。2

    2. 实例分割（-seg）：不仅可以检测对象，还可以在图像中区分和分割对象的模型。

    3. 姿势估计（-pose）：非常适合根据关键点识别和估计人体或物体的姿势。

    4. 方向边界框（-obb）：这些模型检测并绘制旋转的边界框，对于有角度的物体特别有用。

    5.分类（-cls）：旨在将对象分类到预定义类别中的模型。

    此外，这些模型有不同的尺寸以满足不同的性能需求：

    -Nano (n)：超轻且快速。

    -Small (s)：针对速度和中等精度进行了优化。

    -Medium (m)：在速度和精度之间取得平衡。

    -Large (l)：增强精度，适用于复杂任务。

    -Extra-Large (x)：最高精度，专为资源密集型任务而设计。

    这些选项使 YOLOv11 高度灵活，可满足各种用例和资源需求。

    如何使用模型？

   您可以参考https://docs.ultralytics.com/models/yolo11/#usage-examples上的文档来了解如何使用该模型。

YOLOv11 图像分割演示

 1. 安装依赖项

!pip install ultralytics
from IPython import display
display.clear_output()import ultralytics
ultralytics.checks()from ultralytics import YOLOfrom IPython.display import display, Image

    之后，我们需要将模型下载到我们的环境中。请从Ultralytics页面选择并下载所需的模型。

! wget https://github.com/ultralytics/assets/releases/download/v 8.3.0 / yolo11x-seg.pt

    2. 准备自定义数据集

    我将使用来自 Roboflow 的数据集（对于其他任务，请参阅文档以获取有关准备数据集的具体说明）。现在，让我们从 Roboflow 下载正确的格式。

import roboflowroboflow.login()rf = roboflow.Roboflow()project = rf.workspace("model-examples").project("car-parts-instance-segmentation")
dataset = project.version(1).download("yolov11")

    创建一个data.yaml文件，为模型提供有关数据集的信息。

import yamlwith open(f"{dataset.location}/data.yaml", 'r') as f:dataset_yaml = yaml.safe_load(f)
dataset_yaml["train"] = "../train/images"
dataset_yaml["val"] = "../valid/images"
dataset_yaml["test"] = "../test/images"
with open(f"{dataset.location}/data.yaml", 'w') as f:yaml.dump(dataset_yaml, f)

    3. 训练模型

    训练模型的步骤因任务而异。请确保选择正确的任务并相应地正确配置路径和模型设置。

%cd {HOME}!yolo task=segment mode=train model="/content/yolo11x-seg.pt" data="/content/car-parts-instance-segmentation-1/data.yaml" epochs=10 imgsz=640

    4. 检查矩阵和结果

!ls {HOME}/runs/segment/train/

%cd {HOME}
Image(filename=f'{HOME}/runs/segment/train/confusion_matrix.png', width=600)

%cd {HOME}
Image(filename=f'{HOME}/runs/segment/train/results.png', width=600)

%cd {HOME}
Image(filename=f'{HOME}/runs/segment/train/val_batch0_pred.jpg', width=600)

    5. 验证自定义模型

    训练模型后，验证其性能以确保其符合您的期望非常重要。验证过程涉及使用一组之前从未见过的数据测试模型，以评估其准确率、精确率、召回率和其他指标。

%cd {HOME}!yolo task=segment mode=val model={HOME}/runs/segment/train/weights/best.pt data={dataset.location}/data.yaml

    6. 使用自定义模型进行推理

%cd {HOME}
!yolo task=segment mode=predict model={HOME}/runs/segment/train/weights/best.pt cnotallow=0.25 source={dataset.location}/test/images save=true

import glob
from IPython.display import Image, displayfor image_path in glob.glob(f'{HOME}/runs/segment/predict2/*.jpg')[:3]:display(Image(filename=image_path, height=600))print("\n")

 源码下载：

https：//github.com/tententgc/notebook-colab/blob/main/yolo11x_segmentation.ipynb

https://github.com/tententgc/notebook-colab/blob/main/train_yolo11_object_detection_on_custom_dataset.ipynb

2.3、YOLO11和SAHI提升小目标检测效果

什么是切片推理？

    切片推理是指将大尺寸或高分辨率图像细分为较小的片段（切片），在这些切片上进行物体检测，然后重新编译切片以重建原始图像上的物体位置。在计算资源有限的情况下，或者在处理极高分辨率图像（否则可能导致内存问题）时，这种技术非常宝贵。

    切片推理的优势

• 减轻计算负担：较小的图像切片处理速度更快，内存消耗更少，可在低端硬件上更流畅地运行。
• 保持检测质量：由于每个切片都是独立处理的，因此只要切片足够大，能够捕捉到感兴趣的物体，物体检测的质量就不会降低。
• 增强的可扩展性：该技术可以更容易地在不同尺寸和分辨率的图像上进行物体检测，因此非常适合从卫星图像到医疗诊断的广泛应用。

SAHI 简介

    SAHI（切片辅助超推理）是一个创新库，旨在优化大规模高分辨率图像的物体检测算法。其核心功能在于将图像分割成易于管理的切片，在每个切片上运行物体检测，然后将结果拼接在一起。SAHI 与包括YOLO 系列在内的一系列物体检测模型兼容，从而在确保优化使用计算资源的同时提供了灵活性。

    SAHI 的主要特点

• 无缝集成：SAHI 可毫不费力地与YOLO 模型集成，这意味着您无需修改大量代码即可开始切片和检测。
• 资源效率：通过将大图像分解成更小的部分，SAHI 可优化内存使用，让您在资源有限的硬件上运行高质量的检测。
• 高精度：SAHI 采用智能算法，在拼接过程中合并重叠的检测框，从而保持检测精度。​

YOLO11和SAHI结合使用步骤

 【1】安装必要的库。执行下面指令安装即可：

pip install -U ultralytics sahi

    【2】实例化模型。您可以像这样实例化YOLO11模型，用于对象检测：

from sahi import AutoDetectionModeldetection_model = AutoDetectionModel.from_pretrained(model_type="yolov8",model_path="yolo11n.pt",confidence_threshold=0.3,device="cpu",  # or 'cuda:0'
)

 【3】执行标准预测。使用图像路径或 numpy 图像执行标准推理。

from sahi.predict import get_prediction# With an image path
result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)# With a numpy image
result = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)

    【4】结果可视化。导出并可视化预测的边界框和遮罩：

result.export_visuals(export_dir="demo_data/")
Image("demo_data/prediction_visual.png")

    还可以通过指定切片尺寸和重叠率来执行切片推理：

from sahi.predict import get_sliced_predictionresult = get_sliced_prediction("demo_data/small-vehicles1.jpeg",detection_model,slice_height=256,slice_width=256,overlap_height_ratio=0.2,overlap_width_ratio=0.2,
)

    【5】批量预测。用于对图像目录进行批量预测：

from sahi.predict import predictpredict(model_type="yolov8",model_path="path/to/yolo11n.pt",model_device="cpu",  # or 'cuda:0'model_confidence_threshold=0.4,source="path/to/dir",slice_height=256,slice_width=256,overlap_height_ratio=0.2,overlap_width_ratio=0.2,
)

    【6】效果对比。YOLO11 与 YOLO11 + SAHI推理：

2.4、搭建YOLO11的Web端应用

Streamlit 简介

    Streamlit是一个开源的Python框架，旨在帮助开发人员快速、轻松地构建交互式Web应用程序。以下是对Streamlit的基本特点：

• 无代码界面：Streamlit允许开发人员使用简单的Python代码创建复杂的Web应用程序，无需编写HTML、CSS或JavaScript。
• 实时交互：Streamlit应用程序能够响应用户的输入并立即更新，提供无缝的用户体验。
• 易于部署：使用一个简单的命令，即可将Streamlit应用程序部署到Heroku、AWS等云平台。
• 社区支持：Streamlit拥有一个活跃而充满活力的社区，提供全面的文档、教程和示例，以及论坛和讨论组，方便用户交流和学习。

YOLO11 简介

    YOLO11请参考公众号前面的文章即可，下面是链接：

    YOLOv11来了：将重新定义AI的可能性

    实战 | YOLO11自定义数据集训练实现缺陷检测 (标注+训练+预测 保姆级教程)

搭建YOLO11 Web应用

    第一步：安装需要的库。

    安装streamlit，指令：

pip install streamlit

    测试安装是否成功：

streamlit hello

    安装ultralytics，指令：

pip install ultralytics

    下载YOLO11预训练模型：

https://github.com/ultralytics/ultralytics

     第二步：编写代码。

    YOLO11目标检测代码：

from ultralytics import YOLO
import streamlit as st
import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFontmodel = YOLO("yolo11s.pt")st.header('YOLO11 Object Detection Web App')
st.subheader('-'*60)
st.write('公众号：OpenCV与AI深度学习')uploaded_file = st.file_uploader("Upload an image...", type=["jpg", "jpeg", "png"])
if uploaded_file is not None:image = Image.open(uploaded_file)results = model(image)reulst_image = results[0].plot()st.image(reulst_image, captinotallow="YOLO11 Object Detection", channels="BGR")

    YOLO11实例分割代码：

from ultralytics import YOLO
import streamlit as st
import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFontmodel = YOLO("yolo11s-seg.pt")st.header('YOLO11 Instance Segmentation Web App')
st.subheader('-'*60)
st.write('公众号：OpenCV与AI深度学习')uploaded_file = st.file_uploader("Upload an image...", type=["jpg", "jpeg", "png"])
if uploaded_file is not None:image = Image.open(uploaded_file)results = model(image)reulst_image = results[0].plot()st.image(reulst_image, captinotallow="YOLO11 Instance Segmentation", channels="BGR")

    YOLO11姿态估计代码：

from ultralytics import YOLO
import streamlit as st
import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFontmodel = YOLO("yolo11n-pose.pt")st.header('YOLO11 Pose Estimation Web App')
st.subheader('-'*60)
st.write('公众号：OpenCV与AI深度学习')uploaded_file = st.file_uploader("Upload an image...", type=["jpg", "jpeg", "png"])
if uploaded_file is not None:image = Image.open(uploaded_file)results = model(image)reulst_image = results[0].plot()st.image(reulst_image, captinotallow="YOLO11 Pose Estimation", channels="BGR")

     第三步：运行测试。

    运行测试指令，cmd输入：

streamlit run xxx.py

    打开网页，上传图片测试：

    目标检测：

    实例分割：

    姿态估计：

    大家也可以尝试YOLO11图像分类或OBB检测任务，如果想搭建一个界面和功能更丰富的应用可以参考Streamlit开发手册，下面是网站：

http://cw.hubwiz.com/card/c/streamlit-manual/

3、Yolo5

3.1、YoloV5和Mask RCNN实现汽车表面划痕检测

该项目专注于汽车划痕检测，与不同类型产品的自主质量检测系统的开发同步。例如，在停车场，这种检测为客户提供了汽车安全无虞的保证；此外，如果发生什么情况，检测系统将有助于仔细处理这种情况。

    此外，在这个项目中学到的技术可以在其他项目中补充或结合其他一些问题使用，例如质量保证和二手车估价。我将这个问题作为单类分类问题来解决，将凹痕、损坏和划痕视为划痕，并进一步在烧瓶的帮助下制作了一个基本的应用程序。本文将向您介绍我在完成这个项目时获得的所有想法、代码、算法和知识，我通过Mask RCNN和Yolov5实现了该项目。

实现步骤

 【1】准备数据集。

    为了收集数据，我做了一个数据抓取器，使用Beautiful Soup从adobe、Istock photo等在线网站抓取数据。为了收集数据，我做了一个数据抓取器，使用Beautiful Soup从adobe、Istock photo等在线网站抓取数据。

url = 'https://stock.adobe.com/in/search/images?k=car%20scratch' # 向 url 发出请求r = requests.get(url) # 创建我们的汤soup = BeautifulSoup(r.文本, 'html.parser') print(soup.title.text)
images = soup.find_all('img') for images[-1] 中的图像：name = image['alt'] link = image['src'] with open(name.replace(' ', '-').将('/', '') + '.jpg', 'wb') 替换为 f: im = requests.get(link) f.write(im.content)

    但它不起作用，因为由于网站有关抓取的隐私政策，大多数图像没有被抓取。由于隐私问题，我直接从 Istock photo、Shutter photo 和 Adobe 下载了图像。

    我们从大约 80 张图像开始，增加到 350 张图像，并进一步增加到大约 900 张图像以进行最终标注。

    【2】使用Mask RCNN进行实例分割。

    图像分割是根据像素将图像分割成不同的区域。Mask RCNN 是用于实例分割的模型，实例分割是图像分割的一种子类型，用于分离对象边界中的实例。它进一步建立在 Faster RCNN 的基础上。Faster RCNN 对于每个对象有两个输出，作为类标签和边界框偏移，而 Mask RCNN 是第三个输出（即对象的掩码）的相加。

    Mask RCNN 的架构由以下部分组成：

• 骨干网
• 区域提案网络
• 掩模表示
• ROI对齐

    使用 Mask RCNN 检测汽车划痕的优点是，我们可以使用多边形而不仅仅是边界框，并在目标上创建掩模，进一步使我们能够以更准确、更简洁的方式获得和可视化结果。

    让我们开始使用 Mask RCNN 来实现我们的问题。

    导入必要的库：

# importing libraries
import pandas as pd
import numpy as np
import cv2
import os
import re
from PIL import Image
import albumentations as A
from albumentations.pytorch.transforms import ToTensorV2
import torch
import torchvision
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
from torchvision.models.detection import FasterRCNN
from torchvision.models.detection.rpn import AnchorGenerator
from torch.utils.data import DataLoader, Dataset
from torch.utils.data.sampler import SequentialSampler
from matplotlib import pyplot as plt

    划分数据集：其中使用的数据采用 .csv 格式，其中包含边界框的 x、y、w 和 h 坐标，而数据是使用数据注释器make-sense进行标注的。

image_ids = train_df['image_id'].unique()
print(len(image_ids))
valid_ids = image_ids[-10:]
train_ids = image_ids[:-10]
# valid and train df
valid_df = train_df[train_df['image_id'].isin(valid_ids)]
train_df = train_df[train_df['image_id'].isin(train_ids)]

    创建临时类：创建我们的 Scratch Dataset 类来转换我们的数据集并返回所需的数据。

class ScratchDataset(Dataset):def __init__(self, dataframe, image_dir, transforms=None):super().__init__()self.image_ids = dataframe['image_id'].unique()self.df = dataframeself.image_dir = image_dirself.transforms = transformsdef __getitem__(self, index: int):image_id = self.image_ids[index]records = self.df[self.df['image_id'] == image_id]image = cv2.imread(f'{self.image_dir}/{image_id}.jpg', cv2.IMREAD_COLOR)image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB).astype(np.float32)image /= 255.0boxes = records[['x', 'y', 'w', 'h']].valuesboxes[:, 2] = boxes[:, 0] + boxes[:, 2]boxes[:, 3] = boxes[:, 1] + boxes[:, 3]area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2]-boxes[:, 0])area = torch.as_tensor(area, dtype=torch.float32)# there is only one classlabels = torch.ones((records.shape[0],), dtype=torch.int64)# suppose all instances are not crowdiscrowd = torch.zeros((records.shape[0],), dtype=torch.int64)target = {}target['boxes']=boxestarget['labels']=labelstarget['image_id']=torch.tensor([index])target['area']=areatarget['iscrowd']=iscrowdif self.transforms:sample = {'image':image,'bboxes': target['boxes'],'labels': labels}sample = self.transforms(**sample)image = sample['image']target['boxes'] = torch.tensor(sample['bboxes'])return image, target, image_iddef __len__(self) -> int:return self.image_ids.shape[0]

    这里的“img_dir”是保存图像的目录路径。

    数据增强：在这里，我们使用 Albumentations 进行数据增强。

# Albumenations
def get_train_transform():return A.Compose([A.Flip(0.5),ToTensorV2(p=1.0)], bbox_params={'format':'pascal_voc', 'label_fields':['labels']})
def get_valid_transform():return A.Compose([ToTensorV2(p=1.0)], bbox_params={'format': 'pascal_voc', 'label_fields':['labels']})

    创建模型：我们将使用 Resnet50 模型和 Mask RCNN。

# load a model pre-trained on COCO
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
num_classes = 2 # 1 class scratch+ background
# get number of input features for the classifier
in_features = model.roi_heads.box_predictor.cls_score.in_features
# replace th epre-trained head with a new one
model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)

    让我们继续创建 Averager 类以及训练和验证数据加载器，它们将成为训练模型时的关键组件。

class Averager:def __init__(self):self.current_total = 0.0self.iterations = 0.0def send(self, value):self.current_total += valueself.iterations += 1@propertydef value(self):if self.iterations == 0:return 0else:return 1.0 * self.current_total/ self.iterationsdef reset(self):self.current_total = 0.0self.iterations = 0.0
def collate_fn(batch):return tuple(zip(*batch))
train_dataset = WheatDataset(train_df, DIR_TRAIN, get_train_transform())
valid_dataset = WheatDataset(valid_df, DIR_TRAIN, get_valid_transform())
# split the dataset in train and test set
indices = torch.randperm(len(train_dataset)).tolist()
train_data_loader = DataLoader(train_dataset,batch_size=16,shuffle=False,num_workers=4,collate_fn=collate_fn
)
valid_data_loader = DataLoader(valid_dataset,batch_size=8,shuffle=False,num_workers=4,collate_fn=collate_fn
)

    训练模型：我们正在激活“cuda”并访问 GPU（如果可用）。进一步我们的weight_decay=0.0005，momentum=0.9，动态学习率从0.05开始

device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
images, targets, image_ids = next(iter(train_data_loader))
model.to(device)
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005)
# lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)
lr_scheduler = None
num_epochs = 2
loss_hist = Averager()
itr=1
for epoch in range(num_epochs):loss_hist.reset()for images, targets, image_ids, in train_data_loader:images = list(image.to(device) for image in images)targets = [{k: v.to(device) for k, v in t.items()} for t in targets]loss_dict = model(images, targets)losses = sum(loss for loss in loss_dict.values())loss_value = losses.item()loss_hist.send(loss_value)optimizer.zero_grad()losses.backward()optimizer.step()if itr % 50 == 0:print(f'Iteration #{itr} loss: {loss_value}')itr += 1# update the learning rateif lr_scheduler is not None:lr_scheduler.step()print(f'Epoch #{epoch} loss: {loss_hist.value}')

    但我无法实现这一点，因为仅仅 80 张图像就花费了 10 个小时甚至更长的时间。

    使用 Mask RCNN 进行自定义训练的时间复杂度非常大，并且需要大量的计算能力，而我却无法做到这一点。

    【3】通过 Yolov5 进行物体检测

    Yolo 主要用于目标检测，由 Ultralytics[ github ] 发布，已成为视觉数据分割等领域的基准算法。Yolov5 比 Yolov4 更快、更高效，并且可以很好地推广到新图像。

    Yolov5架构

    该算法的工作原理如下：

• 剩余块
• 边界框回归
• 并集交集(IOU)
• 非极大值抑制.a

    Yolov5更快、更小，并且与以前的版本大致一样准确。在 coco 数据集上进行训练，它可以很好地处理边界框。

    让我们从我们问题案例中 Yolov5 的实现开始；我已经使用 google collab 来运行其中的代码。

    数据标注

    我使用了一个有意义的数据注释器来注释数据集。

    当数据被精确地注释（即小而中肯）时，Yolo 的工作效果不够好，因为它不能很好地泛化到小边界框。

    因此数据标注有点棘手，区域应该统一标注。

    训练：加载模型

model = torch.hub.load('ultralytics/yolov5','yolov5s')

    我们添加了 Yolo 工作所需的 yaml 文件和数据（图像在一个文件夹中，而注释作为文本文件在另一个文件夹中），我们使用批量大小 16 和图像大小 320*320 训练模型。

!cd yolov5 && python train.py --img 320 --batch 16 --epochs 50 --data carScr_up.yaml --weights last.pt

    虽然在 Yolo 文档中，据说需要运行 300 个 epoch 才能获得良好的结果，但我们已将其降低到 50 个 epoch，并且在超参数调整后，我们的模型甚至在 30 个 epoch 内就开始表现得很好。

    对于超参数调整，我们使用 Yolo 提供的演化，其中数据训练 10 个 epoch，进行 300 次演化。

!cd yolov5 && python train.py --img 320 --batch 32 --epochs 10 --data carScr_up.yaml --weights yolov5s.pt --cache --evolve

    结果：

    下图代表实验 4，每个实验都根据不同数量的图像和注释进行训练。对于有划痕的汽车的预测如下：

    在这种情况下，精度和召回率都很小，因为在 Yolo 中，我们处理的是边界框，而这些指标取决于实际框和预测框的并集交集 (IOU)。

    让我们看一下使用 Yolov5 训练数据集 50 个 epoch 后获得的指标

    我们可以看到，在20 个 epoch 后，进度停滞不前，因此，即使我们拥有的数据低于 1000 张图像，Yolo 也能很快地学习这种关系并很好地推广到我们的问题陈述。

    【4】结论

    我们可以看到Yolov5和 Mask RCNN 对于我们的问题陈述非常有效，尽管我无法实现后面的代码。Yolov5 可以很好地跟上我们的问题陈述。在使用 Yolov5 进行自定义训练时，除了指标之外，它能够非常好地进行预测，检测样本图像中的所有划痕和损坏。因此，我们有一个非常好的模型，在其中我们学习如何收集、注释和训练不同的模型以及训练不同模型需要什么。

• 在上面，我将损坏和划痕视为一个类别。
• 数据注释和收集是该解决方案不可或缺的详尽部分。
• 如果我们使用多边形并增加数据集大小，我们肯定可以做得更好。

或者，我们可以点击下面提到的研究论文的链接，其中图像被分为 3*3 网格并用作我们的训练数据。这将导致划痕与图像的比率增加，从而很好地推广到数据集并改进我们的指标。