benchmarks.py
ultralytics\utils\benchmarks.py
目录
1.所需的库和模块
# Ultralytics YOLO 🚀, AGPL-3.0 license
# 对 YOLO 模型格式进行基准测试，以了解其速度和准确性。
# 格式 | `format=argument` | 模型
# PyTorch | - | yolov8n.pt
"""
Benchmark a YOLO model formats for speed and accuracy.
Usage:
from ultralytics.utils.benchmarks import ProfileModels, benchmark
ProfileModels(['yolov8n.yaml', 'yolov8s.yaml']).profile()
benchmark(model='yolov8n.pt', imgsz=160)
Format | `format=argument` | Model
--- | --- | ---
PyTorch | - | yolov8n.pt
TorchScript | `torchscript` | yolov8n.torchscript
ONNX | `onnx` | yolov8n.onnx
OpenVINO | `openvino` | yolov8n_openvino_model/
TensorRT | `engine` | yolov8n.engine
CoreML | `coreml` | yolov8n.mlpackage
TensorFlow SavedModel | `saved_model` | yolov8n_saved_model/
TensorFlow GraphDef | `pb` | yolov8n.pb
TensorFlow Lite | `tflite` | yolov8n.tflite
TensorFlow Edge TPU | `edgetpu` | yolov8n_edgetpu.tflite
TensorFlow.js | `tfjs` | yolov8n_web_model/
PaddlePaddle | `paddle` | yolov8n_paddle_model/
NCNN | `ncnn` | yolov8n_ncnn_model/
"""
import glob
import os
import platform
import re
import shutil
import time
from pathlib import Path
import numpy as np
import torch.cuda
import yaml
from ultralytics import YOLO, YOLOWorld
from ultralytics.cfg import TASK2DATA, TASK2METRIC
from ultralytics.engine.exporter import export_formats
from ultralytics.utils import ARM64, ASSETS, IS_JETSON, IS_RASPBERRYPI, LINUX, LOGGER, MACOS, TQDM, WEIGHTS_DIR
from ultralytics.utils.checks import IS_PYTHON_3_12, check_requirements, check_yolo
from ultralytics.utils.downloads import safe_download
from ultralytics.utils.files import file_size
from ultralytics.utils.torch_utils import get_cpu_info, select_device2.def benchmark(model=WEIGHTS_DIR / "yolov8n.pt", data=None, imgsz=160, half=False, int8=False, device="cpu", verbose=False, eps=1e-3,):
# 这段代码是一个用于评估和测试不同格式导出模型性能的基准测试函数 benchmark 。它主要针对目标检测模型（如YOLO系列），并测试它们在不同设备和配置下的性能。
# 参数 ：
# 1.model ：模型的路径或模型对象。
# 2.data ：用于验证的数据集。
# 3.imgsz ：输入图像的大小。
# 4.half ：是否使用半精度浮点数。
# 5.int8 ：是否使用INT8量化。
# 6.device ：运行模型的设备，如CPU或GPU。
# 7.verbose ：是否输出详细的调试信息。
# 8.eps ：用于计算FPS时的一个小的epsilon值，以避免除以零。
def benchmark(
model=WEIGHTS_DIR / "yolov8n.pt",
data=None,
imgsz=160,
half=False,
int8=False,
device="cpu",
verbose=False,
eps=1e-3,
):
# 对不同格式的 YOLO 模型进行基准测试，以了解其速度和准确性。
"""
Benchmark a YOLO model across different formats for speed and accuracy.
Args:
model (str | Path): Path to the model file or directory.
data (str | None): Dataset to evaluate on, inherited from TASK2DATA if not passed.
imgsz (int): Image size for the benchmark.
half (bool): Use half-precision for the model if True.
int8 (bool): Use int8-precision for the model if True.
device (str): Device to run the benchmark on, either 'cpu' or 'cuda'.
verbose (bool | float): If True or a float, assert benchmarks pass with given metric.
eps (float): Epsilon value for divide by zero prevention.
Returns:
(pandas.DataFrame): A pandas DataFrame with benchmark results for each format, including file size, metric,
and inference time.
Examples:
Benchmark a YOLO model with default settings:
>>> from ultralytics.utils.benchmarks import benchmark
>>> benchmark(model="yolov8n.pt", imgsz=640)
"""
# 这段代码是 benchmark 函数的一部分，它负责初始化和准备模型以及设置设备。
# 设置 Pandas 显示选项。
import pandas as pd # scope for faster 'import ultralytics'
# 设置 Pandas 在输出时最多显示的列数为10。
pd.options.display.max_columns = 10
# 设置 Pandas 在输出时的显示宽度为120个字符。
pd.options.display.width = 120
# 选择设备。调用 select_device 函数来选择运行模型的设备。 select_device 函数通常根据提供的参数（如CPU或GPU）来决定实际使用的设备，并返回该设备。 verbose=False 参数表示不输出额外的调试信息。
# def select_device(device="", batch=0, newline=False, verbose=True):
# -> 用于根据用户提供的设备字符串选择并返回一个合适的 PyTorch 设备对象。返回设备对象。返回一个 PyTorch 设备对象，可以是 GPU、MPS 或 CPU。
# -> return torch.device(arg)
device = select_device(device, verbose=False)
# 加载模型。
# 检查 model 参数是否是字符串或 Path 对象。
if isinstance(model, (str, Path)):
# 如果是，那么将字符串路径转换为 YOLO 模型对象。这里假设 YOLO 是一个已经定义好的类，用于加载和处理YOLO模型。
model = YOLO(model)
# 检查模型是否为端到端模型。
# 使用 getattr 函数尝试获取模型最后一个层的 end2end 属性。如果该属性存在且为 True ，则表示模型是一个端到端模型。如果属性不存在，则默认为 False 。
is_end2end = getattr(model.model.model[-1], "end2end", False)
# 这段代码的目的是为了确保模型已经正确加载，并且设备已经设置好，以便后续的基准测试可以顺利进行。同时，它还检查了模型是否为端到端模型，这对于后续的导出和预测步骤可能很重要，因为不同的模型类型可能需要不同的处理方式。
# 这段代码是 benchmark 函数中的一部分，它负责遍历不同的模型导出格式，并进行一系列的检查，以确保当前的环境和模型配置支持特定的导出格式。
# 初始化变量。
# 初始化一个空列表，用于存储每个导出格式的结果。
y = []
# 记录当前时间，用于计算整个基准测试的耗时。
t0 = time.time()
# 遍历导出格式。
# 通过 export_formats() 函数获取所有支持的导出格式，并将其值解包为 name （格式名称）、 format （格式类型）、 suffix （文件后缀）、 cpu （是否支持CPU）、 gpu （是否支持GPU）五个变量。 enumerate 函数用于获取当前迭代的索引 i 。
# def export_formats(): -> 它返回一个包含不同导出格式的字典。函数返回一个字典，其中键是列名，值是对应的列数据。 -> return dict(zip(["Format", "Argument", "Suffix", "CPU", "GPU"], zip(*x)))
for i, (name, format, suffix, cpu, gpu) in enumerate(zip(*export_formats().values())):
# 设置默认值。设置默认的emoji为"❌"，表示失败， filename 初始化为 None 。
emoji, filename = "❌", None # export defaults 导出默认值。
# 执行检查。
# 块内包含了一系列 assert 语句，用于检查当前环境和模型是否满足特定导出格式的要求。如果某个条件不满足，将抛出 AssertionError 异常。
try:
# Checks
# 检查模型任务是否为"obb"（ Oriented Bounding Box），因为TensorFlow GraphDef不支持OBB任务。
if i == 7: # TF GraphDef
assert model.task != "obb", "TensorFlow GraphDef not supported for OBB task" # TensorFlow GraphDef 不支持 OBB 任务。
# 检查操作系统是否为非ARM64架构的Linux，因为Edge TPU导出只支持这种环境。
elif i == 9: # Edge TPU
assert LINUX and not ARM64, "Edge TPU export only supported on non-aarch64 Linux" # Edge TPU 导出仅支持非 aarch64 Linux。
# 检查操作系统是否为macOS或Linux，并且不是树莓派或NVIDIA Jetson设备。
elif i in {5, 10}: # CoreML and TF.js
assert MACOS or LINUX, "CoreML and TF.js export only supported on macOS and Linux" # CoreML 和 TF.js 导出仅支持 macOS 和 Linux。
assert not IS_RASPBERRYPI, "CoreML and TF.js export not supported on Raspberry Pi" # Raspberry Pi 不支持 CoreML 和 TF.js 导出。
assert not IS_JETSON, "CoreML and TF.js export not supported on NVIDIA Jetson" # NVIDIA Jetson 不支持 CoreML 和 TF.js 导出。
# 检查Python版本是否不是3.12，因为CoreML不支持Python 3.12。
if i in {5}: # CoreML
assert not IS_PYTHON_3_12, "CoreML not supported on Python 3.12" # Python 3.12 不支持 CoreML。
# 检查模型是否不是 YOLOWorld 类型，因为 YOLOWorldv2 的TensorFlow导出尚未被 onnx2tf 支持。
if i in {6, 7, 8}: # TF SavedModel, TF GraphDef, and TFLite
assert not isinstance(model, YOLOWorld), "YOLOWorldv2 TensorFlow exports not supported by onnx2tf yet" # onnx2tf 尚不支持 YOLOWorldv2 TensorFlow 导出。
# 同上，检查模型是否不是 YOLOWorld 类型。
if i in {9, 10}: # TF EdgeTPU and TF.js
assert not isinstance(model, YOLOWorld), "YOLOWorldv2 TensorFlow exports not supported by onnx2tf yet" # onnx2tf 尚不支持 YOLOWorldv2 TensorFlow 导出。
# 检查模型是否不是 YOLOWorld 类型，并且不是端到端模型，同时确保操作系统是Linux或macOS，因为Paddle不支持Windows导出。
if i in {11}: # Paddle
assert not isinstance(model, YOLOWorld), "YOLOWorldv2 Paddle exports not supported yet" # YOLOWorldv2 Paddle 导出尚不支持。
assert not is_end2end, "End-to-end models not supported by PaddlePaddle yet" # PaddlePaddle 尚不支持端到端模型。
assert LINUX or MACOS, "Windows Paddle exports not supported yet" # 尚不支持 Windows Paddle 导出。
# 检查模型是否不是 YOLOWorld 类型，因为 YOLOWorldv2 的NCNN导出尚未支持。
if i in {12}: # NCNN
assert not isinstance(model, YOLOWorld), "YOLOWorldv2 NCNN exports not supported yet" # YOLOWorldv2 NCNN 导出尚不支持。
# 检查设备类型是否支持CPU或GPU，并确保相应的 cpu 或 gpu 标志为 True 。
if "cpu" in device.type:
assert cpu, "inference not supported on CPU" # CPU 不支持推理。
if "cuda" in device.type:
assert gpu, "inference not supported on GPU" # GPU 不支持推理。
# 这些检查确保了在尝试导出模型之前，当前的环境和模型配置是兼容的，从而避免了不必要的错误和异常。如果所有检查都通过，代码将继续执行模型导出和性能测试。如果某个检查失败，将捕获异常并记录错误信息，然后继续下一个格式的检查。
# Export
# 这段代码是 benchmark 函数中负责模型导出的部分。它根据提供的格式参数 format 来决定如何导出模型，并进行相应的检查。
# ["PyTorch", "-", ".pt", True, True],
# 条件判断。
# 检查导出格式是否为 - ，这通常表示不需要实际导出模型，而是直接使用当前的 PyTorch 模型。
if format == "-":
# PyTorch 格式导出。
# 如果不需要导出，那么 filename 被设置为模型的检查点路径 ckpt_path ，如果 ckpt_path 不存在，则使用 cfg （模型配置文件路径）。
filename = model.ckpt_path or model.cfg
# 直接将当前的 PyTorch 模型赋值给 exported_model 。
exported_model = model # PyTorch format
# 其他格式导出。
# 如果 format 不是 - ，那么执行实际的导出操作。
else:
# 调用模型的 export 方法，传入相应的参数，包括图像大小 imgsz 、导出格式 format 、是否使用半精度 half 、是否使用 INT8 量化 int8 、设备 device 和是否输出详细信息 verbose 。
# def export(self, **kwargs,) -> str: -> 用于将 PyTorch 模型导出到不同的格式。返回导出的结果，这通常是一个文件路径。 -> return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model)
filename = model.export(imgsz=imgsz, format=format, half=half, int8=int8, device=device, verbose=False)
# 使用导出的文件路径创建一个新的 YOLO 模型对象， task 参数从原始模型中获取。
exported_model = YOLO(filename, task=model.task)
# 导出成功检查。断言导出的文件名中包含预期的后缀 suffix ，如果不包含，则抛出异常，表示导出失败。
assert suffix in str(filename), "export failed"
# 设置成功标志。如果导出成功，将 emoji 设置为 "❎"，表示导出操作成功。
emoji = "❎" # indicates export succeeded
# 这段代码确保了模型可以被导出到指定的格式，并且在导出后能够被重新加载和使用。通过这种方式， benchmark 函数可以测试不同导出格式的性能和兼容性。
# Predict
# 这段代码是 benchmark 函数中负责模型预测的部分。它在模型导出成功后，对导出的模型进行预测操作，以测试模型的推理能力。
# 预测前的条件检查。
# 确保当前任务不是“pose”（姿态估计）或者当前格式不是TensorFlow GraphDef（ i != 7 ），因为TensorFlow GraphDef不支持姿态估计任务的推理。
assert model.task != "pose" or i != 7, "GraphDef Pose inference is not supported" # 不支持 GraphDef 姿势推断。
# 确保当前格式不是Edge TPU（ i != 9 ）或TensorFlow.js（ i != 10 ），因为这两种格式不支持推理操作。
assert i not in {9, 10}, "inference not supported" # Edge TPU and TF.js are unsupported
# 确保当前格式不是CoreML（ i != 5 ）或者操作系统是Darwin（即macOS），因为CoreML推理只在macOS上支持。
assert i != 5 or platform.system() == "Darwin", "inference only supported on macOS>=10.13" # CoreML 推理仅支持 macOS >=10.13。
# 如果当前格式是NCNN（ i == 12 ），则检查模型是否为端到端模型。
if i in {12}:
# 确保模型不是端到端模型，因为NCNN预测还不支持端到端模型中的 torch.topk 操作。
assert not is_end2end, "End-to-end torch.topk operation is not supported for NCNN prediction yet" # NCNN 预测尚不支持端到端 torch.topk 操作。
# 执行预测。
# 使用导出的模型 exported_model 对指定的图像 ASSETS / "bus.jpg" 进行预测。这里使用的参数包括 ：
# ASSETS / "bus.jpg" ：预测使用的图像路径。
# imgsz=imgsz ：图像大小参数，与之前导出模型时使用的图像大小一致。
# device=device ：指定预测时使用的设备，如CPU或GPU。
# half=half ：指定是否使用半精度浮点数进行预测。
exported_model.predict(ASSETS / "bus.jpg", imgsz=imgsz, device=device, half=half)
# 这段代码的目的是确保在支持的格式和任务上，导出的模型能够成功进行推理操作，并测试其性能。通过这种方式，可以验证模型在不同格式下的实用性和准确性。
# Validate
# 这段代码是 benchmark 函数中负责模型验证的部分。它在模型预测之后，对导出的模型进行验证操作，以评估模型的性能和准确性。
# 设置验证数据和指标。
# 确定用于验证的数据集。如果用户提供了 data 参数，则使用该参数；否则，根据模型的任务类型（ model.task ）从 TASK2DATA 字典中选择相应的数据集。例如，如果任务是目标检测（ task=detect ），则可能使用 coco8.yaml 数据集。
data = data or TASK2DATA[model.task] # task to dataset, i.e. coco8.yaml for task=detect
# 确定用于评估模型性能的指标。根据模型的任务类型从 TASK2METRIC 字典中选择相应的评估指标。例如，如果任务是目标检测，则可能使用 mAP50-95(B) 指标。
key = TASK2METRIC[model.task] # task to metric, i.e. metrics/mAP50-95(B) for task=detect
# 执行模型验证。
# 调用导出的模型 exported_model 的 val 方法进行验证。传入的参数包括 ：
# data=data ：用于验证的数据集。
# batch=1 ：批处理大小为1。
# imgsz=imgsz ：图像大小参数。
# plots=False ：不生成绘图。
# device=device ：指定验证时使用的设备。
# half=half ：指定是否使用半精度浮点数。
# int8=int8 ：指定是否使用INT8量化。
# verbose=False ：不输出详细信息。
# results ：存储验证结果的对象。
results = exported_model.val(
data=data, batch=1, imgsz=imgsz, plots=False, device=device, half=half, int8=int8, verbose=False
)
# 提取验证结果。
# 从验证结果中提取模型的性能指标（ metric ）和推理速度（ speed ）。
metric, speed = results.results_dict[key], results.speed["inference"]
# 计算每秒帧数（FPS）， eps 是一个小的epsilon值，用于避免除以零。
fps = round(1000 / (speed + eps), 2) # frames per second
# 记录验证结果。
# 将验证结果添加到列表 y 中。每个元素包含以下信息 ：
# name ：导出格式的名称。
# "✅" ：表示验证成功。
# round(file_size(filename), 1) ：导出文件的大小，单位为MB。
# round(metric, 4) ：模型的性能指标，保留四位小数。
# round(speed, 2) ：推理速度，单位为毫秒，保留两位小数。
# fps ：每秒帧数，保留两位小数。
# def file_size(path): -> 返回指定文件或目录的大小，单位为兆字节（MB）。总大小除以 mb 转换为兆字节，并返回这个值。 -> return sum(f.stat().st_size for f in path.glob("**/*") if f.is_file()) / mb
y.append([name, "✅", round(file_size(filename), 1), round(metric, 4), round(speed, 2), fps])
# 这段代码的目的是确保导出的模型不仅能够成功进行预测，而且能够在特定的数据集上达到预期的性能和准确性。通过这种方式，可以全面评估模型在不同格式下的性能。
# 这段代码是 benchmark 函数中的异常处理部分，它负责捕获并处理在模型导出、预测或验证过程中发生的任何异常。
# 捕获异常。
# 捕获在 try 块中发生的任何异常，并将异常对象赋值给变量 e 。
except Exception as e:
# 调试信息。
# 检查是否设置了 verbose 参数，如果为 True ，则执行以下操作。
if verbose:
# 断言异常类型为 AssertionError ，如果不是，则抛出一个新的异常，表明基准测试失败，并提供失败的格式名称 name 和异常信息 e 。
assert type(e) is AssertionError, f"Benchmark failure for {name}: {e}" # {name} 的基准测试失败：{e}。
# 记录警告。使用日志记录器 LOGGER 输出一条警告信息，表明基准测试失败，并提供失败的格式名称 name 和异常信息 e 。
LOGGER.warning(f"ERROR ❌️ Benchmark failure for {name}: {e}") # 错误 ❌️ {name} 的基准测试失败：{e}。
# 记录失败结果。
# 将失败的结果添加到列表 y 中。每个元素包含以下信息 ：
# name ：导出格式的名称。
# emoji ：表示失败的表情符号，通常是 "❌"。
# round(file_size(filename), 1) ：导出文件的大小，单位为MB，如果 filename 为 None 或文件大小计算失败，则为 None 。
# None ：由于测试失败，性能指标（mAP）、推理时间（t_inference）和每秒帧数（FPS）都是未知的，因此用 None 表示。
y.append([name, emoji, round(file_size(filename), 1), None, None, None]) # mAP, t_inference
# 这段代码确保了即使在发生异常的情况下，也能记录和报告基准测试的结果。通过这种方式，可以识别和诊断模型导出、预测或验证过程中的问题，同时保持测试流程的完整性和可追踪性。
# 这段代码是 benchmark 函数的最后部分，它负责输出系统信息、整理和记录基准测试结果，并在必要时进行最终的验证。
# Print results
# 打印系统信息。调用 check_yolo 函数打印系统信息，包括使用的设备等。
# def check_yolo(verbose=True, device=""): -> 用于检查并返回一个关于 YOLO（You Only Look Once）软件和硬件环境的摘要信息。
check_yolo(device=device) # print system info
# 创建 DataFrame 。使用前面收集的结果 y 创建一个 pandas DataFrame ，列名由基准测试的不同指标组成，包括格式、状态、大小、性能指标、推理时间、FPS等。
df = pd.DataFrame(y, columns=["Format", "Status❔", "Size (MB)", key, "Inference time (ms/im)", "FPS"])
# 记录基准测试结果。
# 获取模型检查点路径的文件名。
name = Path(model.ckpt_path).name
# 构建一个字符串 s ，包含基准测试的总结信息和DataFrame的字符串表示。这里 time.time() - t0 计算了基准测试的总耗时。
s = f"\nBenchmarks complete for {name} on {data} at imgsz={imgsz} ({time.time() - t0:.2f}s)\n{df}\n" # 对 {name} 的 {data} 的基准测试已完成，imgsz={imgsz} ({time.time() - t0:.2f}s)\n{df}。
# 使用日志记录器 LOGGER 输出基准测试的总结信息。
LOGGER.info(s)
# 将基准测试的结果追加写入到 benchmarks.log 文件中，忽略编码错误。
with open("benchmarks.log", "a", errors="ignore", encoding="utf-8") as f:
f.write(s)
# 最终验证。
# 如果 verbose 参数被设置，并且是一个浮点数，执行以下操作。
if verbose and isinstance(verbose, float):
# 从DataFrame中提取性能指标列的值。
metrics = df[key].array # values to compare to floor
# 将 verbose 参数的值作为性能指标的最低阈值 floor 。
floor = verbose # minimum metric floor to pass, i.e. = 0.29 mAP for YOLOv5n
# pd.notna(*args, **kwargs)
# pd.notna() 是一个 Pandas 库中的函数，用于检查数据是否为非空（不是 NaN）。这个函数返回一个与输入同形状的布尔型（Boolean）对象，其中的元素为 True 表示相应的输入元素是“非空”的，即不是 NaN（Not a Number）或 None。
# 参数 ：
# *args ：可以接受多个参数，每个参数都是一个 Pandas 对象（如 Series 或 DataFrame），或者是其他类型的数组结构。
# **kwargs ：可以接受额外的关键字参数，这些参数会被传递给底层的 NumPy 函数 numpy.isfinite() 。
# 返回值 ：
# 返回一个与输入同形状的布尔型 Pandas 对象，其中的元素为 True 表示相应的输入元素是非空的。
# 断言所有有效的性能指标值都大于 floor ，如果有任何一个指标值小于 floor ，则抛出异常，表明基准测试失败。
assert all(x > floor for x in metrics if pd.notna(x)), f"Benchmark failure: metric(s) < floor {floor}" # 基准测试失败：指标 < floor {floor}。
# 返回结果。函数返回包含基准测试结果的DataFrame。
return df
# 这段代码确保了基准测试的结果被完整记录和验证，同时提供了一个清晰的输出，使得用户可以快速了解模型在不同配置下的性能表现。通过这种方式，可以有效地评估和比较不同模型或不同配置的性能。
# 这个函数可以用于测试和比较不同模型在不同配置下的性能，帮助开发者了解模型在不同环境下的表现。3.class RF100Benchmark:
# 这段代码定义了一个名为 RF100Benchmark 的类，它用于基准测试 YOLO 模型在不同格式下的性能，包括速度和准确性。
class RF100Benchmark:
# 对各种格式的 YOLO 模型性能进行速度和准确性基准测试。
"""Benchmark YOLO model performance across various formats for speed and accuracy."""
# __init__ 方法。
def __init__(self):
# 初始化 RF100Benchmark 类，以对各种格式的 YOLO 模型性能进行基准测试。
"""Initialize the RF100Benchmark class for benchmarking YOLO model performance across various formats."""
# 这是一个空列表，用于存储 数据集的名称 。在基准测试过程中，可能会处理多个数据集，因此需要一个列表来跟踪它们的名称。
self.ds_names = []
# 这是另一个空列表，用于存储数据集的 配置文件路径 。每个数据集可能有一个或多个配置文件，这些文件包含了数据集的元数据和设置。
self.ds_cfg_list = []
# 这是一个初始化为 None 的属性，用于存储与 Roboflow 服务的连接实例。Roboflow 是一个机器学习数据平台，可能用于管理和访问数据集。
self.rf = None
# 这是一个列表，包含了在验证过程中需要计算和跟踪的 指标 。这些指标包括 ：
# "class" ：类别名称。
# "images" ：图像数量。
# "targets" ：目标（标注对象）数量。
# "precision" ：精确度。
# "recall" ：召回率。
# "map50" ：平均精度（Average Precision, AP）在 IoU 阈值为 0.5 时的值。
# "map95" ：平均精度（AP）在 IoU 阈值为 0.95 时的值。
self.val_metrics = ["class", "images", "targets", "precision", "recall", "map50", "map95"]
# 这个类的构造函数为后续的方法提供了必要的初始化，使其能够存储和管理基准测试过程中的数据集信息和性能指标。
# 这段代码是 RF100Benchmark 类中的一个方法，用于设置 Roboflow API 密钥并初始化 Roboflow 客户端。
# set_key 方法。参数 ：
# 1. api_key ：这是传递给 set_key 方法的参数，代表用户的 Roboflow API 密钥。
def set_key(self, api_key):
# 设置 Roboflow API 密钥以进行处理。
"""
Set Roboflow API key for processing.
Args:
api_key (str): The API key.
Examples:
Set the Roboflow API key for accessing datasets:
>>> benchmark = RF100Benchmark()
>>> benchmark.set_key("your_roboflow_api_key")
"""
# 这个函数调用 用于检查是否已经安装了 Roboflow 所需的依赖库。如果未安装，则可能触发安装过程或抛出错误。
# def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=(), install=True, cmds=""):
# -> 检查当前环境中是否安装了某些依赖，并在需要时尝试自动安装它们。函数返回值。如果代码执行到这里，表示所有操作成功，返回 True 。
# -> return True
check_requirements("roboflow")
# 导入 Roboflow 模块。
# 这行代码动态地从 roboflow 包中导入 Roboflow 类。这是 Python 中的一种常见模式，用于按需导入模块，以避免在模块顶层导入所有内容，这有助于减少启动时间并避免命名冲突。
from roboflow import Roboflow
# 初始化 Roboflow 客户端。
# 使用提供的 api_key 创建 Roboflow 类的实例，并将其赋值给 self.rf 属性。这样， RF100Benchmark 类的实例就有了一个 Roboflow 客户端，可以用来访问 Roboflow 提供的数据集和其他服务。
self.rf = Roboflow(api_key=api_key)
# 这个方法使得 RF100Benchmark 类能够与 Roboflow 平台进行交互，例如下载数据集、获取数据集信息等。通过这种方式， RF100Benchmark 类可以利用 Roboflow 平台的资源来执行 YOLO 模型的基准测试。
# 这段代码是 RF100Benchmark 类中的 parse_dataset 方法，用于解析数据集链接文件，下载相应的 Roboflow 数据集，并记录数据集名称和配置文件路径。
# parse_dataset 方法。这是一个实例方法，接受一个参数。
# 1.ds_link_txt ：它指定了包含数据集链接的文本文件的名称，默认值为 "datasets_links.txt" 。
def parse_dataset(self, ds_link_txt="datasets_links.txt"):
# 解析数据集链接并下载数据集。
"""
Parse dataset links and download datasets.
Args:
ds_link_txt (str): Path to the file containing dataset links.
Examples:
>>> benchmark = RF100Benchmark()
>>> benchmark.set_key("api_key")
>>> benchmark.parse_dataset("datasets_links.txt")
"""
# 这行代码检查是否存在名为 "rf-100" 的目录。如果存在，则使用 shutil.rmtree 删除该目录，然后使用 os.mkdir 创建一个新的空目录。如果不存在，则直接创建新目录。这样做是为了确保每次运行方法时都从一个干净的目录开始。
(shutil.rmtree("rf-100"), os.mkdir("rf-100")) if os.path.exists("rf-100") else os.mkdir("rf-100")
# os.chdir(path)
# os.chdir() 函数是 Python 的标准库 os 模块中的一个函数，用于更改当前工作目录。
# 参数 ：
# path ：要更改到的目标目录的路径。
# 功能描述 :
# os.chdir(path) 函数将当前工作目录更改为 path 指定的目录。如果 path 不存在或无法访问，将抛出一个异常。
# 异常处理 :
# 当尝试更改到一个不存在或无法访问的目录时， os.chdir() 会抛出 FileNotFoundError 或 PermissionError 异常。因此，在实际使用中，可能需要捕获这些异常来处理错误情况。
# 将当前工作目录更改为 "rf-100" 目录。
os.chdir("rf-100")
# 在 "rf-100" 目录下创建一个名为 "ultralytics-benchmarks" 的子目录。
os.mkdir("ultralytics-benchmarks")
# 调用 safe_download 函数从指定的 URL 下载 datasets_links.txt 文件。这个文件包含了数据集的链接。
safe_download("https://github.com/ultralytics/assets/releases/download/v0.0.0/datasets_links.txt")
# 打开 ds_link_txt 文件。
with open(ds_link_txt) as file:
# 并逐行读取。
for line in file:
# 使用 try 块来捕获解析过程中可能出现的任何异常。
try:
# 使用正则表达式 re.split 按 / 分割每一行的内容，并将结果分配给 _ , url , workspace , project项目名称 , version版本 变量。 _ 是一个惯用的占位符，表示我们不使用这个值。
_, url, workspace, project, version = re.split("/+", line.strip())
# 将数据集的项目名称 project 添加到 self.ds_names 列表中。
self.ds_names.append(project)
# 创建一个包含 项目名称 和 版本 的字符串 proj_version 。
proj_version = f"{project}-{version}"
# 检查 proj_version 指定的路径是否存在。如果不存在，则使用 self.rf （Roboflow 客户端）下载指定的工作区、项目和版本的数据集。
if not Path(proj_version).exists():
self.rf.workspace(workspace).project(project).version(version).download("yolov8")
# 如果数据集已经下载，则打印一条消息。
else:
print("Dataset already downloaded.") # 数据集已下载。
# 将数据集的配置文件路径添加到 self.ds_cfg_list 列表中。路径是当前工作目录、项目版本和 "data.yaml" 文件的组合。
self.ds_cfg_list.append(Path.cwd() / proj_version / "data.yaml")
# 如果在解析过程中发生任何异常，则捕获异常并继续处理下一行。
except Exception:
continue
# 方法返回两个列表。 self.ds_names 包含所有数据集的名称， self.ds_cfg_list 包含所有数据集的配置文件路径。
return self.ds_names, self.ds_cfg_list
# 这个方法使得 RF100Benchmark 类能够从文本文件中读取数据集链接，下载相应的数据集，并为后续的基准测试准备必要的信息。
# 这段代码定义了 RF100Benchmark 类中的一个静态方法 fix_yaml ，其目的是修改 YAML 文件中的路径设置。
# fix_yaml 静态方法。
# staticmethod 装饰器表示这个方法是一个静态方法，意味着它不属于类的任何实例，而是属于类本身。静态方法不能访问类的实例属性或方法，但可以访问类的类属性和类方法。
@staticmethod
# fix_yaml 方法接受一个参数。
# 1.path ：这是要修改的 YAML 文件的路径。
def fix_yaml(path):
# 修复给定 YAML 文件中的训练和验证路径。
"""
Fixes the train and validation paths in a given YAML file.
Args:
path (str): Path to the YAML file to be fixed.
Examples:
>>> RF100Benchmark.fix_yaml("path/to/data.yaml")
"""
# 使用 with 语句打开 path 指定的 YAML 文件，确保文件在操作完成后正确关闭。
with open(path) as file:
# yaml.safe_load(stream, Loader=None, object_pairs_hook=None, version=(1, 2), pure=False, preserve_quotes=False)
# yaml.safe_load() 是 PyYAML 库中的一个函数，用于安全地解析 YAML 文档。
# 参数 ：
# stream ：包含 YAML 文档的输入流，可以是文件对象、字符串等。
# Loader ：指定一个 Loader 类来加载 YAML 文档，默认为 SafeLoader ，它只认识标准 YAML 标签，不能构造任意的 Python 对象。
# object_pairs_hook ：一个函数，用于处理键值对序列，以便在加载映射时自定义 Python 对象的构造。
# version ：指定 YAML 的版本，默认为 (1, 2) ，表示支持的 YAML 版本。
# pure ：如果为 True ，则只使用 Python 的内置类型来加载 YAML 文档。
# preserve_quotes ：如果为 True ，则保持字符串的引号。
# 返回值 ：
# 返回一个 Python 对象，该对象是由 YAML 文档中的第一个文档构建的。如果没有文档，则返回 None 。
# 为什么使用 safe_load 而不是 load ：
# safe_load 只能加载符合 YAML 规范的数据，不会执行 YAML 文件中的任何代码，因此更安全。
# load 函数可以处理更多的数据类型，包括 Python 对象和函数，如果 YAML 文档包含恶意代码，使用 load 可能会导致安全风险。
# 注意事项 ：
# 始终使用 safe_load 来解析不受信任的 YAML 文档，以确保安全。
# 从受信任的来源获取 YAML 文档，以避免潜在的安全问题。
# 定期更新 PyYAML 库，以获得最新的安全补丁。
# 使用 yaml.safe_load(file) 读取 YAML 文件的内容，并将其解析为 Python 数据结构（通常是字典）。
yaml_data = yaml.safe_load(file)
# 设置 yaml_data 字典中的 "train" 和 "val" 键的值分别为 "train/images" 和 "valid/images" 。这将修改 YAML 文件中的训练和验证数据集的路径。
yaml_data["train"] = "train/images"
yaml_data["val"] = "valid/images"
# 再次使用 with 语句以写入模式打开 path 指定的 YAML 文件。
with open(path, "w") as file:
# 使用 yaml.safe_dump(yaml_data, file) 将修改后的 Python 数据结构写回 YAML 文件中。
yaml.safe_dump(yaml_data, file)
# 这个方法通常用于标准化或修复 YAML 文件中的路径，确保它们指向正确的目录。在数据集下载和处理的过程中，这可能是一个常见的需求，特别是当数据集的结构在下载后需要调整以适应特定的框架或工具时。通过这种方式， RF100Benchmark 类可以确保 YAML 文件中的路径设置正确，从而使得数据加载和模型训练过程顺利进行。
# 这段代码是 RF100Benchmark 类中的 evaluate 方法，用于评估模型的性能并记录结果。
# 这是一个实例方法，接受四个参数。
# 1.yaml_path ：包含类别名称的 YAML 文件的路径。
# 2.val_log_file ：验证日志文件的路径，其中包含了模型验证的输出。
# 3.eval_log_file ：评估日志文件的路径，用于记录评估结果。
# 4.list_ind ：数据集名称列表 self.ds_names 中的索引，用于获取当前评估的数据集名称。
def evaluate(self, yaml_path, val_log_file, eval_log_file, list_ind):
# 根据验证结果评估模型性能。
"""
Evaluate model performance on validation results.
Args:
yaml_path (str): Path to the YAML configuration file.
val_log_file (str): Path to the validation log file.
eval_log_file (str): Path to the evaluation log file.
list_ind (int): Index of the current dataset in the list.
Returns:
(float): The mean average precision (mAP) value for the evaluated model.
Examples:
Evaluate a model on a specific dataset
>>> benchmark = RF100Benchmark()
>>> benchmark.evaluate("path/to/data.yaml", "path/to/val_log.txt", "path/to/eval_log.txt", 0)
"""
# 定义一个列表 skip_symbols ，包含在处理验证日志时需要跳过的符号。
skip_symbols = ["🚀", "⚠️", "💡", "❌"]
# 打开 yaml_path 指定的 YAML 文件，并使用 yaml.safe_load 解析文件内容，获取类别名称列表 class_names 。
with open(yaml_path) as stream:
class_names = yaml.safe_load(stream)["names"]
# 这段代码是 evaluate 方法中的一部分，它负责从验证日志文件中提取和处理性能评估数据。
# 使用 with 语句打开 val_log_file 指定的文件，确保文件在操作完成后正确关闭。 encoding="utf-8" 确保文件以 UTF-8 编码方式打开，这对于正确读取包含特殊字符的文件是必要的。
with open(val_log_file, encoding="utf-8") as f:
# file.readlines([sizehint])
# readlines() 是 Python 中文件对象的一个方法，用于读取文件的所有行，并返回一个包含每行作为列表元素的字符串列表。
# 参数 ：
# sizehint ：这是一个可选参数，用于指定返回列表的最大大小。如果提供，文件对象会尝试读取大约 sizehint 行，并将它们存储在列表中返回。如果实际行数少于 sizehint ，则返回的列表将包含实际读取的所有行。如果省略此参数，则返回整个文件的所有行。
# 返回值 ：
# 返回一个字符串列表，其中每个字符串是文件中的一行，包括每行末尾的换行符 \n （如果存在）。
# 注意事项 ：
# 使用 readlines() 一次性读取大文件的所有行可能会消耗大量内存，因为它会将整个文件内容加载到内存中。
# 对于大文件，通常推荐使用循环逐行读取，例如使用 for line in file: ，这样可以更有效地处理文件内容，减少内存使用。
# 逐行读取与 readlines() 的比较 ：
# 在这个逐行读取的示例中，每次迭代只处理文件的一行，而不是一次性将所有行加载到内存中。这种方法更适合处理大文件。
# 读取文件的所有行，并将它们存储在列表 lines 中。
lines = f.readlines()
# 初始化一个空列表 eval_lines ，用于存储处理后的评估数据。
eval_lines = []
# 遍历 lines 列表中的每一行。
for line in lines:
# 对于每一行，检查是否包含 skip_symbols 列表中的任何符号。如果包含，则使用 continue 跳过当前循环迭代，不处理这一行。
if any(symbol in line for symbol in skip_symbols):
continue
# 将当前行按空格分割成多个条目，并将结果存储在列表 entries 中。
entries = line.split(" ")
# filter(function, iterable)
# filter() 是 Python 中的一个内置函数，用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，该对象生成符合条件元素的序列。
# 参数 :
# function ：一个函数，用于判断哪些元素该被包含在最终结果中。这个函数接受一个参数，并返回一个布尔值（True 或 False）。
# iterable ：一个可迭代对象（如列表、元组、字符串等），其中的元素会被传递给 function 函数进行判断。
# 返回值 :
# 返回一个迭代器，该迭代器生成所有使得 function 返回 True 的元素。
# 使用 lambda 表达式 ：
# filter() 函数经常与 lambda 表达式一起使用，以创建更简洁的代码。
# 注意事项 ：
# filter() 返回的是一个迭代器，如果你需要一个列表，可以使用 list() 函数将迭代器转换为列表。
# 如果你使用的是 Python 3， filter() 函数返回的迭代器是惰性的，这意味着它只会在需要的时候生成元素。
# 在 Python 2 中， filter() 返回的是一个列表，但在 Python 3 中，它返回的是一个迭代器，这是一个重要的变化。
# 使用 filter 函数和 lambda 表达式过滤掉 entries 列表中的空字符串。
entries = list(filter(lambda val: val != "", entries))
# 遍历 entries 列表，移除每个条目末尾的换行符 \n 。
entries = [e.strip("\n") for e in entries]
# list.extend(iterable)
# 在 Python 中， .extend() 方法是列表（list）对象的一个方法，用于将一个可迭代对象（如列表、元组、字符串等）的所有元素添加到列表的末尾。
# list ： 需要扩展的列表对象。
# iterable ： 一个可迭代对象，其所有元素将被添加到列表中。
# 返回值 ：
# .extend() 方法没有返回值（即返回 None ），因为它直接修改列表对象本身。
# 使用 extend 方法将新数据添加到 eval_lines 列表中。
eval_lines.extend(
# 这是一个列表推导式，用于构建字典列表。每个字典包含以下键值对：
# "class" : entries[0]
# "images" : entries[1]
# "targets" : entries[2]
# "precision" : entries[3]
# "recall" : entries[4]
# "map50" : entries[5]
# "map95" : entries[6]
{
"class": entries[0],
"images": entries[1],
"targets": entries[2],
"precision": entries[3],
"recall": entries[4],
"map50": entries[5],
"map95": entries[6],
}
# 遍历 entries 列表中的每个条目。
for e in entries
# 是一个条件表达式，只有当条目名称在 class_names 中，或者条目名称为 "all" 且 "(AP)" 和 "(AR)" 不在条目中时，才将字典添加到 eval_lines 列表中。
if e in class_names or (e == "all" and "(AP)" not in entries and "(AR)" not in entries)
)
# 这段代码处理验证日志文件中的每一行，提取性能评估数据，并构建一个包含关键性能指标的字典列表 eval_lines 。它跳过包含特定符号的行，并确保只处理包含有效性能数据的行。最终， eval_lines 列表将被用于进一步的性能评估和记录。
# 这段代码是 evaluate 方法中的一部分，用于确定模型在验证数据集上的平均精度（mAP）值，并将结果写入评估日志文件。
# 初始化一个变量 map_val 并设置其值为 0.0 。这个变量将用于存储模型的平均精度（mAP）值。
map_val = 0.0
# 使用 if 语句检查 eval_lines 列表的长度是否大于 1 ，即是否有多个字典（多个结果）。
if len(eval_lines) > 1:
print("There's more dicts")
# 如果有多个结果，遍历 eval_lines 列表中的每个字典 lst 。
for lst in eval_lines:
# 在每个字典中检查是否存在键 "class" 且其值为 "all" 。这通常表示该结果是整体结果，而不是针对某个特定类别的结果。
if lst["class"] == "all":
# 如果找到这样的字典，将 "map50" 键对应的值赋给 map_val 变量。 map50 通常表示在 IoU 阈值为 0.5 时的平均精度。
map_val = lst["map50"]
# 如果 eval_lines 列表中只有一个结果，执行 else 块中的代码。
else:
print("There's only one dict res")
# 使用列表推导式从 eval_lines 列表中获取所有字典的 "map50" 值，并选择第一个值赋给 map_val 。由于只有一个结果，所以直接取第一个值。
map_val = [res["map50"] for res in eval_lines][0]
# 使用 with 语句以追加模式（ "a" ）打开 eval_log_file 指定的评估日志文件。
with open(eval_log_file, "a") as f:
# 使用 f.write 将当前数据集的名称（ self.ds_names[list_ind] ）和对应的 map_val 值写入文件，并在末尾添加换行符。这样，每次评估的结果都会被追加到文件的末尾，而不是覆盖之前的内容。
f.write(f"{self.ds_names[list_ind]}: {map_val}\n")
# 这段代码处理评估结果，确定模型的平均精度值，并将每个数据集的评估结果记录到评估日志文件中。通过这种方式，可以追踪和比较不同数据集上的性能。
# 这个方法使得 RF100Benchmark 类能够评估模型在每个数据集上的性能，并记录 mAP50 值到评估日志文件中。通过这种方式，可以追踪和比较不同数据集上的性能。4.class ProfileModels:
# 这段代码定义了一个名为 ProfileModels 的类，其目的是对一系列模型进行性能分析。
class ProfileModels:
# ProfileModels 类用于在 ONNX 和 TensorRT 上分析不同的模型。
# 此类分析不同模型的性能，返回模型速度和 FLOP 等结果。
"""
ProfileModels class for profiling different models on ONNX and TensorRT.
This class profiles the performance of different models, returning results such as model speed and FLOPs.
Attributes:
paths (List[str]): Paths of the models to profile.
num_timed_runs (int): Number of timed runs for the profiling.
num_warmup_runs (int): Number of warmup runs before profiling.
min_time (float): Minimum number of seconds to profile for.
imgsz (int): Image size used in the models.
half (bool): Flag to indicate whether to use FP16 half-precision for TensorRT profiling.
trt (bool): Flag to indicate whether to profile using TensorRT.
device (torch.device): Device used for profiling.
Methods:
profile: Profiles the models and prints the result.
Examples:
Profile models and print results
>>> from ultralytics.utils.benchmarks import ProfileModels
>>> profiler = ProfileModels(["yolov8n.yaml", "yolov8s.yaml"], imgsz=640)
>>> profiler.profile()
"""
# ProfileModels 类的构造函数。这是一个初始化方法，用于创建 ProfileModels 类的实例。
# 1.paths ：一个列表，包含要分析的模型的路径。
# 2.num_timed_runs ：在性能分析中要执行的计时运行次数，默认为100次。
# 3.num_warmup_runs ：在开始计时之前执行的预热运行次数，默认为10次，用于预热CPU和GPU。
# 4.min_time ：性能分析的最小时间（以秒为单位），如果计时运行的时间总和未达到这个值，会继续运行直到满足最小时间要求，默认为60秒。
# 5.imgsz ：用于性能分析的输入图像大小，默认为640。
# 6.half ：一个布尔值，指示是否使用半精度（FP16）进行性能分析，默认为True。
# 7.trt ：一个布尔值，指示是否运行 TensorRT 性能分析，默认为True。
# 8.device ：用于性能分析的设备，如果没有指定，则自动选择可用的CUDA设备或CPU。
def __init__(
self,
paths: list,
num_timed_runs=100,
num_warmup_runs=10,
min_time=60,
imgsz=640,
half=True,
trt=True,
device=None,
):
# 初始化 ProfileModels 类以分析模型。
# 注意：
# FP16 'half' 参数选项已从 ONNX 中删除，因为在 CPU 上比 FP32 慢。
"""
Initialize the ProfileModels class for profiling models.
Args:
paths (List[str]): List of paths of the models to be profiled.
num_timed_runs (int): Number of timed runs for the profiling.
num_warmup_runs (int): Number of warmup runs before the actual profiling starts.
min_time (float): Minimum time in seconds for profiling a model.
imgsz (int): Size of the image used during profiling.
half (bool): Flag to indicate whether to use FP16 half-precision for TensorRT profiling.
trt (bool): Flag to indicate whether to profile using TensorRT.
device (torch.device | None): Device used for profiling. If None, it is determined automatically.
Notes:
FP16 'half' argument option removed for ONNX as slower on CPU than FP32.
Examples:
Initialize and profile models
>>> from ultralytics.utils.benchmarks import ProfileModels
>>> profiler = ProfileModels(["yolov8n.yaml", "yolov8s.yaml"], imgsz=640)
>>> profiler.profile()
"""
# 将传入的 paths 列表赋值给实例变量 self.paths ，用于存储模型路径。
self.paths = paths
# 将传入的 num_timed_runs 参数值赋值给实例变量 self.num_timed_runs ，用于存储计时运行的次数。
self.num_timed_runs = num_timed_runs
# 将传入的 num_warmup_runs 参数值赋值给实例变量 self.num_warmup_runs ，用于存储预热运行的次数。
self.num_warmup_runs = num_warmup_runs
# 将传入的 min_time 参数值赋值给实例变量 self.min_time ，用于存储性能分析的最小时间。
self.min_time = min_time
# 将传入的 imgsz 参数值赋值给实例变量 self.imgsz ，用于存储输入图像的大小。
self.imgsz = imgsz
# 将传入的 half 参数值赋值给实例变量 self.half ，用于指示是否使用半精度。
self.half = half
# 将传入的 trt 参数值赋值给实例变量 self.trt ，用于指示是否运行TensorRT性能分析。
self.trt = trt # run TensorRT profiling
# 将传入的 device 参数值赋值给实例变量 self.device 。
# 如果 device 参数为 None ，则使用 torch.device 函数自动选择一个设备。如果CUDA设备可用，则选择CUDA设备（通常是第一个CUDA设备，索引为0），否则选择CPU。
self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
# 这个构造函数为后续的性能分析方法提供了必要的初始化和配置，使得 ProfileModels 类能够根据不同的配置对模型进行性能分析。
# 这段代码是 ProfileModels 类中的 profile 方法，用于对 YOLO 模型进行性能分析，包括速度和准确性，并支持不同的格式，如 PyTorch、ONNX 和 TensorRT。
# 这是一个实例方法，用于执行模型的性能分析。
def profile(self):
# 对 YOLO 模型在包括 ONNX 和 TensorRT 在内的各种格式中的速度和准确性进行分析。
"""Profiles YOLO models for speed and accuracy across various formats including ONNX and TensorRT."""
# 调用一个实例方法 get_files 来获取要分析的文件列表。
files = self.get_files()
# 如果 files 列表为空，表示没有找到匹配的 .pt 或 .onnx 文件，打印一条消息并返回。
if not files:
print("No matching *.pt or *.onnx files found.") # 未找到匹配的 *.pt 或 *.onnx 文件。
return
# 初始化两个列表 ： table_rows 用于存储表格行数据， output 用于存储最终的输出结果。
table_rows = []
output = []
# 遍历 files 列表中的每个文件。
for file in files:
# 对于每个文件，创建一个对应的 TensorRT 引擎文件路径。
engine_file = file.with_suffix(".engine")
# 这行代码检查当前处理的文件 file 的后缀名是否是 .pt 、 .yaml 或 .yml 中的一个。这个条件判断用于确定文件类型，以便进行相应的处理。
if file.suffix in {".pt", ".yaml", ".yml"}:
# 如果文件是 .pt 、 .yaml 或 .yml 中的一种，那么这行代码创建一个 YOLO 类的实例。 YOLO 是一个用于加载和处理 YOLO 模型的自定义类。 str(file) 将 file 对象转换为字符串路径，这是 YOLO 类构造函数所需的。
model = YOLO(str(file))
# 调用 model 实例的 fuse 方法。这个方法用于优化模型，例如融合某些层，以便在后续的 model.info() 调用中报告正确的参数和 GFLOPs（Giga Floating Point Operations per second，即每秒十亿次浮点运算）。这一步是为了确保性能分析的准确性。
model.fuse() # to report correct params and GFLOPs in model.info()
# 调用 model 实例的 info 方法，获取模型的详细信息，如参数数量、计算复杂度等，并将这些信息存储在 model_info 变量中。这些信息可能用于后续的性能分析和结果报告。
model_info = model.info()
# 这段代码是 profile 方法中的一部分，它负责处理模型的导出和性能分析，特别是针对 TensorRT 和 ONNX 格式。
# 这行代码检查几个条件。 self.trt ：是否启用 TensorRT 性能分析。 self.device.type != "cpu" ：当前设备是否不是 CPU（即是否为 GPU）。 not engine_file.is_file() ：对应的 TensorRT 引擎文件（ .engine ）是否尚未创建。
if self.trt and self.device.type != "cpu" and not engine_file.is_file():
# 如果上述条件全部满足，调用 model 实例的 export 方法，将模型导出为 TensorRT 引擎文件（ .engine ）。这个方法的参数包括 ：
# format="engine" ：指定导出格式为 TensorRT 引擎。
# half=self.half ：指定是否使用半精度（FP16）。
# imgsz=self.imgsz ：指定输入图像的大小。
# device=self.device ：指定用于导出的设备。
# verbose=False ：指定是否输出详细信息。
engine_file = model.export(
format="engine",
half=self.half,
imgsz=self.imgsz,
device=self.device,
verbose=False,
)
# 接下来，无论是否导出了 TensorRT 引擎文件，都调用 model 实例的 export 方法，将模型导出为 ONNX 格式。参数与上述类似，但不包括 half 参数，因为 ONNX 导出通常不涉及精度转换。
onnx_file = model.export(
format="onnx",
imgsz=self.imgsz,
device=self.device,
verbose=False,
)
# 如果当前处理的文件后缀是 .onnx ，表示它已经是一个 ONNX 文件。
elif file.suffix == ".onnx":
# 调用 get_onnx_model_info 方法来获取 ONNX 模型的信息，并将文件本身赋值给 onnx_file 。
model_info = self.get_onnx_model_info(file)
onnx_file = file
# 如果文件既不是 .pt 、 .yaml 、 .yml 也不是 .onnx ，那么跳过当前迭代，继续处理下一个文件。
else:
continue
# 这段代码处理模型的导出和性能分析，特别是对于 TensorRT 和 ONNX 格式。它确保了只有在必要时才导出模型，并且能够处理已经存在的 ONNX 文件。通过这种方式， ProfileModels 类可以对不同格式的模型进行性能分析，包括利用 TensorRT 和 ONNX 的优势。
# 这段代码继续执行 ProfileModels 类中的 profile 方法，用于收集性能分析数据，生成表格行和结果字典，并将最终结果输出。
# 调用实例方法 profile_tensorrt_model 来分析 TensorRT 引擎文件的性能。这个方法接受引擎文件的路径（转换为字符串），执行性能测试，并返回测试结果，存储在变量 t_engine 中。
t_engine = self.profile_tensorrt_model(str(engine_file))
# 调用实例方法 profile_onnx_model 来分析 ONNX 文件的性能。这个方法接受 ONNX 文件的路径（转换为字符串），执行性能测试，并返回测试结果，存储在变量 t_onnx 中。
t_onnx = self.profile_onnx_model(str(onnx_file))
# 调用实例方法 generate_table_row 来创建一个表格行，包含文件名（ file.stem ），ONNX 性能结果（ t_onnx ），TensorRT 性能结果（ t_engine ）和模型信息（ model_info ）。这个表格行被添加到 table_rows 列表中。
table_rows.append(self.generate_table_row(file.stem, t_onnx, t_engine, model_info))
# 调用实例方法 generate_results_dict 来创建一个结果字典，包含文件名（ file.stem ），ONNX 性能结果（ t_onnx ），TensorRT 性能结果（ t_engine ）和模型信息（ model_info ）。这个字典被添加到 output 列表中。
output.append(self.generate_results_dict(file.stem, t_onnx, t_engine, model_info))
# 调用实例方法 print_table 来打印 table_rows 列表中的所有表格行。这个方法可能使用 pandas 库或其他方式来格式化和输出表格数据。
self.print_table(table_rows)
# 方法返回 output 列表，其中包含了每个模型的性能分析结果。
return output
# 这段代码完成了模型性能分析的最后步骤，包括执行性能测试、生成表格和结果字典、打印表格，并返回性能分析结果。通过这种方式， ProfileModels 类提供了一个完整的性能分析流程，使得用户可以清晰地了解不同模型在不同格式下的性能表现。
# 这个方法提供了一个全面的模型性能分析流程，包括模型加载、格式转换、性能测试和结果输出。通过这种方式，可以评估不同模型在不同格式下的性能。
# 这段代码定义了 ProfileModels 类中的 get_files 方法，其功能是收集所有用户提供的相关模型文件的路径。
# 这是一个实例方法，不接收额外的参数，仅使用实例变量 self.paths 。
def get_files(self):
# 返回用户给出的所有相关模型文件的路径列表。
"""Returns a list of paths for all relevant model files given by the user."""
# 初始化一个空列表 files ，用于存储找到的文件路径。
files = []
# 遍历 self.paths 列表中的每个路径，并将其转换为 Path 对象，以便使用路径操作。
for path in self.paths:
path = Path(path)
# 如果 path 是一个目录，定义一个列表 extensions 包含要搜索的文件扩展名。
if path.is_dir():
extensions = ["*.pt", "*.onnx", "*.yaml"]
# 使用列表推导式和 glob.glob 方法搜索目录下所有匹配的文件，并将结果添加到 files 列表中。
# files.extend(...) ：这是一个方法调用，用于将列表推导式的结果添加到 files 列表中。 extend 方法将传入的迭代器中的每个元素添加到列表的末尾。
# [file for ext in extensions for file in glob.glob(str(path / ext))] ：这是一个嵌套的列表推导式，它生成一个包含文件路径的列表。
# for ext in extensions ：外层循环遍历 extensions 列表中的每个扩展名。 extensions 是一个包含文件扩展名模式的列表，例如 ["*.pt", "*.onnx", "*.yaml"] 。
# for file in glob.glob(str(path / ext)) ：内层循环使用 glob.glob 函数查找与每个扩展名模式匹配的所有文件。 path / ext 表示路径和扩展名的组合， str(path / ext) 将这个路径转换为字符串，因为 glob.glob 需要字符串参数。
# glob.glob ：这是一个Python标准库函数，用于查找与指定模式匹配的所有文件路径。它返回一个字符串列表，其中包含所有匹配的文件路径。
files.extend([file for ext in extensions for file in glob.glob(str(path / ext))])
# 如果 path 是一个文件且其后缀名在指定的集合中，将该文件的路径（转换为字符串）添加到 files 列表中。
elif path.suffix in {".pt", ".yaml", ".yml"}: # add non-existing
files.append(str(path))
# 如果 path 不是目录也不是指定后缀的文件，使用 glob.glob 搜索所有匹配的文件，并将结果添加到 files 列表中。
else:
files.extend(glob.glob(str(path)))
# 打印出将要进行性能分析的文件列表，使用 sorted 函数对文件路径进行排序。
print(f"Profiling: {sorted(files)}")
# 返回一个列表，其中包含排序后的 files 列表中的每个文件路径，再次转换为 Path 对象。
return [Path(file) for file in sorted(files)]
# get_files 方法用于收集和整理所有相关模型文件的路径，以便进行后续的性能分析。它支持目录和单个文件的搜索，并能够处理多种文件类型。通过这种方式， ProfileModels 类可以灵活地处理用户提供的各种类型的模型文件路径。
# 这段代码定义了 ProfileModels 类中的 get_onnx_model_info 方法，其功能是从一个 ONNX 模型文件中提取元数据，包括参数数量、GFLOPs（每秒十亿次浮点运算次数）、输入形状等。
# 这是一个实例方法，接受一个参数.
# 1.onnx_file ：它是 ONNX 模型文件的路径。
def get_onnx_model_info(self, onnx_file: str):
# 从 ONNX 模型文件中提取元数据，包括参数、GFLOP 和输入形状。
"""Extracts metadata from an ONNX model file including parameters, GFLOPs, and input shape."""
# 方法返回一个元组，包含四个浮点数，分别代表 ：
# num_layers ：模型中的层数。
# num_params ：模型中的参数数量。
# num_gradients ：模型中的梯度数量（可能用于计算反向传播中的参数数量）。
# num_flops ：模型的浮点运算次数，通常用来估算模型的计算复杂度。
return 0.0, 0.0, 0.0, 0.0 # return (num_layers, num_params, num_gradients, num_flops)
# 注意事项当前的实现只是一个占位符，返回了四个零值。在实际应用中，需要实现具体的逻辑来解析 ONNX 文件并计算这些值。这可能涉及到使用 onnx 库来加载 ONNX 模型，然后遍历模型的节点和参数来计算层数、参数数量等信息。GFLOPs 的计算可能需要更复杂的分析，包括考虑每层的运算和激活函数。
# 这段代码定义了一个名为 iterative_sigma_clipping 的静态方法，用于通过迭代 sigma 剪切（也称为迭代 sigma 裁剪）算法去除数据中的异常值（outliers）。
# @staticmethod 装饰器表示这个方法是一个静态方法，不依赖于类的实例或类本身，可以不需要创建对象直接通过类来调用。
@staticmethod
# 1.data ：是传入的数据。
# 2.sigma ：是标准差的倍数，用于定义异常值的范围，默认为2。
# 3.max_iters ：是最大迭代次数，默认为3。
def iterative_sigma_clipping(data, sigma=2, max_iters=3):
# 根据指定的 sigma 和迭代次数对数据应用迭代 sigma 裁剪来删除异常值。
"""Applies iterative sigma clipping to data to remove outliers based on specified sigma and iteration count."""
# 将输入的数据 data 转换为 NumPy 数组，以便使用 NumPy 提供的数学函数进行操作。
data = np.array(data)
# 使用 for 循环进行最多 max_iters 次迭代。
for _ in range(max_iters):
# 在每次迭代中，计算当前数据的均值 mean 和标准差 std 。
mean, std = np.mean(data), np.std(data)
# 根据 均值 和 标准差 计算异常值的范围，并创建一个新的数据集 clipped_data ，只包含非异常值。
clipped_data = data[(data > mean - sigma * std) & (data < mean + sigma * std)]
# 如果 clipped_data 的长度与原始数据 data 的长度相同，说明没有更多的异常值可以剪切，退出循环。
if len(clipped_data) == len(data):
break
# 如果有异常值被剪切，更新 data 为 clipped_data ，以便下一次迭代使用。
data = clipped_data
# 方法返回最终的数据处理结果，即去除了异常值后的数据集。
return data
# 这个方法通过迭代地剪切超出均值一定标准差范围内的数据点来去除异常值，是一种常用的数据预处理技术，特别适用于天文学和图像处理等领域的数据清洗。通过这种方式，可以提高数据分析的准确性和鲁棒性。
# TensorRT 引擎模型是 NVIDIA TensorRT™ 软件套件中的核心组件，它是一种针对 NVIDIA GPU 硬件平台优化的高性能深度学习推理引擎。
# 以下是 TensorRT 引擎模型的关键特点和功能：
# 1. 高性能推理
# TensorRT 引擎模型通过多种优化技术，如层融合、权重量化、内存优化等，显著提高了深度学习模型在 NVIDIA GPU 上的推理速度。这些优化使得模型能够以低延迟和高吞吐量运行，特别适合实时应用和服务。
# 2. 优化技术
# 层融合：将多个层合并为一个层，减少内存访问和计算开销。
# 权重量化：将浮点数权重转换为低精度（如 INT8 或 FP16）以减少模型大小和加快计算速度。
# 内存优化：优化内存使用，减少内存带宽需求，提高数据传输效率。
# 3. 异构计算和批处理推理
# TensorRT 利用 GPU 的高并行计算能力进行高效推理，并支持批处理输入，提高 GPU 使用效率。
# 4. 动态输入形状
# TensorRT 支持动态输入形状，可以灵活处理不同大小的输入，这对于处理不同分辨率的图像或视频尤其有用。
# 5. 易于集成
# TensorRT 支持多种深度学习框架，如 TensorFlow、PyTorch、ONNX 等，并提供 C++ 和 Python API，方便开发和集成。
# 6. 插件机制
# TensorRT 支持自定义层和操作，通过插件机制扩展 TensorRT 的功能。
# 7. 灵活性和可扩展性
# TensorRT 提供了灵活的配置选项，允许开发者根据具体的应用需求调整优化策略。
# 8. 部署和运行
# TensorRT 引擎模型可以通过 NVIDIA Triton ™ 推理服务软件进行部署、运行和扩展，该软件包括 TensorRT 作为后端，提供高吞吐量、动态批处理、并发模型执行等优势。
# 9. 与主要框架集成
# TensorRT 直接集成到 PyTorch、Hugging Face 和 TensorFlow 中，通过简单的代码实现推理速度的显著提升。
# 10. 性能测试
# 在 MLPerf 推理行业标准基准测试中，TensorRT 为 NVIDIA 赢得了所有性能测试，证明了其在深度学习推理中的卓越性能。
# 总的来说，TensorRT 引擎模型是 NVIDIA 提供的一种强大的工具，用于在 NVIDIA GPU 上实现深度学习模型的快速、高效推理，特别适合于生产环境中的应用。
# 这段代码实现了 ProfileModels 类中的 profile_tensorrt_model 方法，用于分析使用 TensorRT 优化后的 YOLO 模型的性能。
# 这是一个实例方法，接受两个参数。
# 1.engine_file ：是 TensorRT 引擎文件的路径。
# 2.eps ：是一个浮点数，用于数值计算中的精度控制，默认值为 1e-3 （即 0.001）。
def profile_tensorrt_model(self, engine_file: str, eps: float = 1e-3):
# 使用 TensorRT 分析 YOLO 模型性能，测量平均运行时间和标准差。
"""Profiles YOLO model performance with TensorRT, measuring average run time and standard deviation."""
# 如果没有启用 TensorRT 或引擎文件不存在，则返回 (0.0, 0.0) ，表示无法进行性能分析。
if not self.trt or not Path(engine_file).is_file():
return 0.0, 0.0
# Model and input
# 加载 TensorRT 引擎文件创建 YOLO 模型实例。
model = YOLO(engine_file)
# numpy.random.rand(d0, d1, ..., dn)
# np.random.rand() 是 NumPy 库中的一个函数，用于生成随机数。
# 参数 ：
# d0, d1, ..., dn ：生成随机数的形状参数，可以是整数或者元组。如果不提供任何参数，将返回一个随机的浮点数。
# 返回值 ：
# 返回一个或一组随机样本，样本值在区间 [0.0, 1.0) 之间，即大于等于0.0且小于1.0。
# 注意事项 ：
# np.random.rand() 生成的随机数是均匀分布的，即每个数在 [0.0, 1.0) 区间内出现的概率是相等的。
# 如果需要生成其他分布的随机数，可以使用 NumPy 提供的其他随机数生成函数，如 np.random.randn() （正态分布）或 np.random.randint() （整数的均匀分布）。
# np.random.rand() 生成的随机数是伪随机数，由随机数生成器决定，可以通过 np.random.seed() 设置随机数种子以获得可重复的结果。
# 生成随机输入数据 input_data ，尺寸为 self.imgsz x self.imgsz x 3 ，数据类型为 np.float32 ，这是因为 TensorRT 通常需要 FP32 输入。
input_data = np.random.rand(self.imgsz, self.imgsz, 3).astype(np.float32) # must be FP32
# Warmup runs
# 这段代码是用于测量模型预热运行所需时间的一部分。
# 初始化变量 elapsed 为 0.0 ，它将用来存储预热运行的总时间。
elapsed = 0.0
# 使用 for 循环进行三次预热运行。 _ 是一个惯用的占位符，表示循环变量不会被使用。
for _ in range(3):
# 在每次预热运行开始前，使用 time.time() 函数获取当前时间（以秒为单位），并将其存储在 start_time 变量中。
start_time = time.time()
# 进行 self.num_warmup_runs 次模型推理运行， self.num_warmup_runs 是在类初始化时设置的预热运行次数。
for _ in range(self.num_warmup_runs):
# 调用模型的推理函数，传入随机生成的输入数据 input_data ，设置图像尺寸 imgsz ，并指定 verbose 参数为 False ，表示不输出额外的调试信息。
model(input_data, imgsz=self.imgsz, verbose=False)
# 在所有预热运行完成后，再次使用 time.time() 获取当前时间，并计算与 start_time 的差值，即本次预热运行的总时间，然后更新 elapsed 变量。
elapsed = time.time() - start_time
# 这段代码通过三次预热运行来模拟模型在实际使用中的预热过程，确保模型和硬件都达到稳定状态。每次预热运行的时间被累加到 elapsed 变量中，可以用来评估模型预热阶段的性能。在实际的性能测试中，预热是一个重要的步骤，因为它可以帮助减少系统和硬件的初始延迟对性能测试结果的影响。
# Compute number of runs as higher of min_time or num_timed_runs
# 这行代码计算实际需要执行的计时运行次数 num_runs 。
# self.min_time ：这是在类初始化时设置的最小时间（以秒为单位），表示性能测试的最小持续时间。
# elapsed ：这是预热运行的总时间。
# eps ：这是一个小的正数（例如 1e-3 ），用于避免除以零的情况。
# self.num_warmup_runs ：这是在类初始化时设置的预热运行次数。
# self.num_timed_runs ：这是在类初始化时设置的计时运行次数。
# 计算步骤 ：
# 计算预热运行的平均时间。
# elapsed + eps ：在预热运行的总时间上加上一个很小的数 eps ，以避免除以零。
# self.min_time / (elapsed + eps) ：计算在给定的最小时间 self.min_time 内可以执行多少次预热运行。
# * self.num_warmup_runs ：将上述结果乘以预热运行次数 self.num_warmup_runs ，得到在最小时间内可以执行的总运行次数。
# 取整。
# round(...) ：将上述计算结果四舍五入到最接近的整数。
# 计算计时运行的总次数。
# self.num_timed_runs * 50 ：将计时运行次数 self.num_timed_runs 乘以 50，得到一个基准的计时运行总次数。
# 取最大值。
# max(...) ：取上述两个计算结果中的最大值，确保计时运行的总次数至少为 self.num_timed_runs * 50 。
# 这行代码的目的是确保性能测试的持续时间至少为 self.min_time 秒，同时保证计时运行的次数至少为 self.num_timed_runs * 50 。这样可以平衡测试的准确性和效率，避免因为运行次数太少而影响测试结果的可靠性。
num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs * 50)
# Timed runs
# 这段代码是 profile_tensorrt_model 方法中用于执行计时运行、去除异常值（使用 sigma 剪切），并计算平均运行时间和标准差的部分。
# 初始化一个空列表 run_times ，用于存储每次计时运行的结果。
run_times = []
# 使用 for 循环执行 num_runs 次计时运行。 TQDM 是一个进度条库，用于显示运行进度， range(num_runs) 生成一个序列， desc=engine_file 设置进度条的描述为引擎文件的名称。
for _ in TQDM(range(num_runs), desc=engine_file):
# 在每次计时运行中，调用模型的推理函数，传入输入数据 input_data 和图像尺寸 imgsz ，并设置 verbose 参数为 False 以避免输出额外信息。
results = model(input_data, imgsz=self.imgsz, verbose=False)
# 将推理结果中的推理时间（以毫秒为单位）添加到 run_times 列表中。
run_times.append(results[0].speed["inference"]) # Convert to milliseconds
# 使用 iterative_sigma_clipping 方法对 run_times 列表进行迭代 sigma 剪切，以去除异常值。 np.array(run_times) 将列表转换为 NumPy 数组， sigma=2 和 max_iters=3 是迭代 sigma 剪切的参数。
run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=3) # sigma clipping
# 计算并返回去除了异常值后的运行时间列表 run_times 的平均值和标准差。 np.mean 和 np.std 分别计算平均值和标准差。
return np.mean(run_times), np.std(run_times)
# 这段代码通过执行多次计时运行来测量模型的推理时间，并使用迭代 sigma 剪切方法去除异常值，最后返回运行时间的平均值和标准差。这为评估模型性能提供了重要的统计数据，可以帮助识别性能瓶颈和优化模型。
# 这个方法提供了一个完整的性能分析流程，包括预热、计时运行、去除异常值和计算统计数据。通过这种方式，可以准确地评估 TensorRT 优化后的 YOLO 模型的性能。
# ONNX（Open Neural Network Exchange）是一个开放的神经网络交换格式，由微软和Facebook等公司于2017年发起，旨在促进不同的深度学习框架之间的模型互操作性。
# ONNX定义了一套标准的运算符和序列化模型的文件格式，使得用户可以在不同的深度学习训练和推理框架之间无缝地转换模型。
# ONNX的主要特点包括：
# 1. 跨框架兼容性：允许模型从一个框架（如PyTorch或TensorFlow）导出，然后在另一个框架中使用，这大大增强了模型的可移植性。
# 2. 模型结构和权重：ONNX模型包含了模型的结构（即计算图）和权重参数等信息，这使得模型可以在不同的环境和平台上保持一致的行为。
# 3. 性能优化：ONNX模型可以被不同的推理引擎优化，例如TensorRT、ONNX Runtime等，以提高模型的运行效率。
# 4. 模型验证：ONNX提供了模型验证工具，确保模型在转换过程中的准确性和完整性。
# 5. 社区支持：ONNX得到了广泛的社区支持，包括ONNX Model Zoo，这是一个包含多种高质量预训练模型的开源仓库。
# ONNX模型的组成：
# Graph（图）：ONNX模型的核心，表示模型的计算流程，由节点（Node）和边（Edge）组成，边指示数据流和节点之间的连接。
# Node（节点）：代表图中的一个运算符，可以是卷积、激活函数等。
# Tensor（张量）：表示图中的数据，包括模型的输入、输出和中间数据。
# 使用场景：
# 模型转换：将PyTorch、TensorFlow等框架的模型转换为ONNX格式，以便在其他框架或推理引擎中使用。
# 模型部署：在不同的硬件平台上部署ONNX模型，如CPU、GPU、FPGA等。
# 性能优化：利用ONNX兼容的推理引擎对模型进行优化，提高推理速度。
# 模型共享：在研究和开发社区之间共享和使用预训练的ONNX模型。
# ONNX的出现为深度学习模型的交换、部署和优化提供了一个统一的标准，促进了人工智能技术的快速发展和应用。
# 这段代码是 ProfileModels 类中的 profile_onnx_model 方法，用于分析 ONNX 模型的性能，测量平均推理时间和标准差。
# 这是一个实例方法，接受两个参数。
# 1.onnx_file ：是 ONNX 模型文件的路径。
# 2.eps ：是一个浮点数，用于数值计算中的精度控制，默认值为 1e-3 （即 0.001）。
def profile_onnx_model(self, onnx_file: str, eps: float = 1e-3):
# 分析 ONNX 模型，测量多次运行的平均推理时间和标准差。
"""Profiles an ONNX model, measuring average inference time and standard deviation across multiple runs."""
# check_requirements() 函数调用用于检查是否已经安装了 onnxruntime 依赖。如果未安装，则可能触发安装过程或抛出错误。
check_requirements("onnxruntime")
# 导入 onnxruntime 模块，并将其别名设置为 ort ，这是 onnxruntime 的常用缩写。
import onnxruntime as ort
# Session with either 'TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'
# 这段代码是用于配置和初始化一个 ONNX 模型推理会话的过程，包括设置会话选项、创建会话、获取输入张量信息，并确定输入数据的形状。
# 配置 ONNX 推理会话。
# 创建一个 SessionOptions 对象，用于配置 ONNX 运行时会话的选项。
sess_options = ort.SessionOptions()
# 设置会话选项的图优化级别为 ORT_ENABLE_ALL ，这将启用所有可用的图优化，以提高推理性能。
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
# 设置会话选项的 intra_op_num_threads 属性为 8，这限制了执行操作时使用的线程数。这对于控制并发和优化 CPU 使用非常有用。
sess_options.intra_op_num_threads = 8 # Limit the number of threads
# 创建一个 InferenceSession 对象，用于加载和运行 ONNX 模型。这里指定了模型文件路径 onnx_file ，会话选项 sess_options ，以及执行提供者 providers ，这里选择了 CPU 执行提供者。
sess = ort.InferenceSession(onnx_file, sess_options, providers=["CPUExecutionProvider"])
# 获取输入张量信息。
# 从会话中获取输入张量，并选择第一个输入张量。 get_inputs() 方法返回一个包含所有输入张量的列表。
input_tensor = sess.get_inputs()[0]
# 获取输入张量的类型，这将用于确定如何正确地生成输入数据。
input_type = input_tensor.type
# 检查输入张量的形状是否为动态的。如果形状中的所有维度都是正整数，则不是动态的。动态形状意味着模型可以接受不同大小的输入。
dynamic = not all(isinstance(dim, int) and dim >= 0 for dim in input_tensor.shape) # dynamic input shape
# 如果输入形状是动态的，则使用预设的形状 (1, 3, self.imgsz, self.imgsz) ，否则使用模型定义的输入形状。这里 (1, 3, self.imgsz, self.imgsz) 表示一个具有 1 个批次、3 个颜色通道、 self.imgsz 高度和宽度的输入张量。
input_shape = (1, 3, self.imgsz, self.imgsz) if dynamic else input_tensor.shape
# 这段代码为 ONNX 模型的推理会话提供了必要的配置和初始化，包括选择执行提供者、设置会话选项、获取输入张量信息，并确定输入数据的形状。这些步骤是进行模型推理前的必要准备工作，确保模型可以正确地加载和执行。
# Mapping ONNX datatype to numpy datatype
# 这段代码负责将ONNX模型的输入数据类型映射到NumPy支持的数据类型，并生成相应的随机输入数据，以及获取输入和输出张量的名称。
# 这段代码检查输入张量 input_tensor 的类型 input_type ，并将其映射到相应的NumPy数据类型。
# 如果 input_type 包含 float16 ，则使用NumPy的 np.float16 。
if "float16" in input_type:
input_dtype = np.float16
# 如果 input_type 包含 float ，则使用NumPy的 np.float32 。
elif "float" in input_type:
input_dtype = np.float32
# 如果 input_type 包含 double ，则使用NumPy的 np.float64 。
elif "double" in input_type:
input_dtype = np.float64
# 如果 input_type 包含 int64 ，则使用NumPy的 np.int64 。
elif "int64" in input_type:
input_dtype = np.int64
# 如果 input_type 包含 int32 ，则使用NumPy的 np.int32 。
elif "int32" in input_type:
input_dtype = np.int32
# 如果 input_type 不匹配任何已知类型，则抛出一个 ValueError 异常，指出不支持的ONNX数据类型。
else:
raise ValueError(f"Unsupported ONNX datatype {input_type}") # 不支持的 ONNX 数据类型 {input_type}。
# 生成随机输入数据。
# 使用 np.random.rand() 函数生成一个形状为 input_shape 的随机浮点数数组，并将其转换为对应的NumPy数据类型 input_dtype 。这个数组将作为模型的输入数据。
input_data = np.random.rand(*input_shape).astype(input_dtype)
# 获取输入和输出张量的名称。
# 获取 输入张量的名称 input_name ，这通常用于在执行推理时指定输入数据。
input_name = input_tensor.name
# 获取 输出张量的名称 output_name ，这用于从推理结果中提取输出数据。
output_name = sess.get_outputs()[0].name
# 这段代码完成了ONNX模型推理前的准备工作，包括数据类型的映射、生成随机输入数据，以及获取输入和输出张量的名称。这些步骤确保了可以正确地向模型提供输入，并从模型获取输出。
# Warmup runs
# 这段代码是用于执行模型的预热运行，以确保模型和硬件都达到稳定状态，减少初始启动延迟对性能测试的影响。
# 初始化变量 elapsed 为 0.0 ，它将用来存储预热运行的总时间。
elapsed = 0.0
# 使用 for 循环进行三次预热运行。这里的 _ 是一个惯用的占位符，表示循环变量不会被使用。
for _ in range(3):
# 在每次预热运行开始前，使用 time.time() 函数获取当前时间（以秒为单位），并将其存储在 start_time 变量中。
start_time = time.time()
# 进行 self.num_warmup_runs 次模型推理运行， self.num_warmup_runs 是在类初始化时设置的预热运行次数。
for _ in range(self.num_warmup_runs):
# 调用 sess.run() 方法执行一次模型推理。这个方法接受两个参数 ： 一个是输出张量的名称列表，另一个是输入数据的字典，其中键是输入张量的名称，值是对应的输入数据。
sess.run([output_name], {input_name: input_data})
# 在所有预热运行完成后，再次使用 time.time() 获取当前时间，并计算与 start_time 的差值，即本次预热运行的总时间，然后更新 elapsed 变量。
elapsed = time.time() - start_time
# 这段代码通过三次预热运行来模拟模型在实际使用中的预热过程，确保模型和硬件都达到稳定状态。每次预热运行的时间被累加到 elapsed 变量中，可以用来评估模型预热阶段的性能。在实际的性能测试中，预热是一个重要的步骤，因为它可以帮助减少系统和硬件的初始延迟对性能测试结果的影响。
# Compute number of runs as higher of min_time or num_timed_runs
# 这行代码计算了实际需要执行的计时运行次数 num_runs ，确保性能测试满足最小时间要求，同时考虑到预热运行的平均时间。
# self.min_time ：这是在类初始化时设置的最小时间（以秒为单位），表示性能测试的最小持续时间。
# elapsed ：这是预热运行的总时间。
# eps ：这是一个小的正数（例如 1e-3 ），用于避免除以零的情况。
# self.num_warmup_runs ：这是在类初始化时设置的预热运行次数。
# elf.num_timed_runs ：这是在类初始化时设置的计时运行次数。
# 计算步骤。
# 计算预热运行的平均时间。
# elapsed + eps ：在预热运行的总时间上加上一个很小的数 eps ，以避免除以零。
# self.min_time / (elapsed + eps) ：计算在给定的最小时间 self.min_time 内可以执行多少次预热运行。
# * self.num_warmup_runs ：将上述结果乘以预热运行次数 self.num_warmup_runs ，得到在最小时间内可以执行的总运行次数。
# 取整。
# round(...) ：将上述计算结果四舍五入到最接近的整数。
# 取最大值。
# max(...) ：取上述计算结果和 self.num_timed_runs 的较大值，确保计时运行的总次数至少为 self.num_timed_runs 。
# 这行代码的目的是确保性能测试的持续时间至少为 self.min_time 秒，同时保证计时运行的次数至少为 self.num_timed_runs 。这样可以平衡测试的准确性和效率，避免因为运行次数太少而影响测试结果的可靠性。通过这种方式，可以更准确地评估模型的性能。
num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs)
# Timed runs
# 这段代码是 profile_onnx_model 方法中用于执行计时运行、去除异常值（使用 sigma 剪切），并计算平均运行时间和标准差的部分。
# 初始化一个空列表 run_times ，用于存储每次计时运行的结果。
run_times = []
# 使用 for 循环执行 num_runs 次计时运行。 TQDM 是一个进度条库，用于显示运行进度， range(num_runs) 生成一个序列， desc=onnx_file 设置进度条的描述为 ONNX 文件的名称。
for _ in TQDM(range(num_runs), desc=onnx_file):
# 在每次计时运行开始前，使用 time.time() 函数获取当前时间（以秒为单位），并将其存储在 start_time 变量中。
start_time = time.time()
# 调用 sess.run() 方法执行一次模型推理。这个方法接受两个参数 ：一个是输出张量的名称列表，另一个是输入数据的字典，其中键是输入张量的名称，值是对应的输入数据。
sess.run([output_name], {input_name: input_data})
# 在推理完成后，再次使用 time.time() 获取当前时间，并计算与 start_time 的差值，即本次推理的运行时间。然后将时间转换为毫秒，并添加到 run_times 列表中。
run_times.append((time.time() - start_time) * 1000) # Convert to milliseconds
# 使用 iterative_sigma_clipping 方法对 run_times 列表进行迭代 sigma 剪切，以去除异常值。 np.array(run_times) 将列表转换为 NumPy 数组， sigma=2 和 max_iters=5 是迭代 sigma 剪切的参数。
run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=5) # sigma clipping
# 计算并返回去除了异常值后的运行时间列表 run_times 的平均值和标准差。 np.mean 和 np.std 分别计算平均值和标准差。
return np.mean(run_times), np.std(run_times)
# 这段代码通过执行多次计时运行来测量模型的推理时间，并使用迭代 sigma 剪切方法去除异常值，最后返回运行时间的平均值和标准差。这为评估模型性能提供了重要的统计数据，可以帮助识别性能瓶颈和优化模型。
# 这个方法提供了一个完整的性能分析流程，包括预热、计时运行、去除异常值和计算统计数据。通过这种方式，可以准确地评估 ONNX 模型的性能。
# 这段代码定义了 ProfileModels 类中的 generate_table_row 方法，用于生成包含模型性能指标的表格行字符串。
# 这是一个实例方法，接受四个参数。
# 1.model_name ：模型的名称。
# 2.t_onnx ：ONNX 模型的推理时间统计，包含平均时间和标准差。
# 3.t_engine ：TensorRT 引擎模型的推理时间统计，包含平均时间和标准差。
# 4.model_info ：模型的信息元组，包含层数、参数数量、梯度数量和浮点运算次数（FLOPs）。
def generate_table_row(self, model_name, t_onnx, t_engine, model_info):
# 生成包含模型性能指标（包括推理时间和模型详细信息）的表行字符串。
"""Generates a table row string with model performance metrics including inference times and model details."""
# 从 model_info 元组中解包模型信息，分别赋值给 layers （层数） 、 params （参数数量） 、 gradients （梯度数量） 和 flops （浮点运算次数） 。
layers, params, gradients, flops = model_info
# 返回一个格式化的字符串，表示表格的一行。字符串包含以下内容 ：
# model_name ：模型名称，左对齐，占据18个字符宽度。
# self.imgsz ：图像尺寸。
# - ：占位符，表示该位置没有内容。
# t_onnx[0]:.2f ：ONNX 模型的平均推理时间，保留两位小数，单位为毫秒。
# t_onnx[1]:.2f ：ONNX 模型的标准差，保留两位小数，单位为毫秒。
# t_engine[0]:.2f ：TensorRT 引擎模型的平均推理时间，保留两位小数，单位为毫秒。
# t_engine[1]:.2f ：TensorRT 引擎模型的标准差，保留两位小数，单位为毫秒。
# params / 1e6:.1f ：模型参数数量，除以 1e6 转换为百万，保留一位小数。
# flops:.1f ：模型的浮点运算次数，保留一位小数。
return (
f"| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.2f} ± {t_onnx[1]:.2f} ms | {t_engine[0]:.2f} ± "
f"{t_engine[1]:.2f} ms | {params / 1e6:.1f} | {flops:.1f} |"
)
# 这个方法生成一个格式化的字符串，用于在表格中显示模型的性能指标和细节。这种格式通常用于报告或展示性能测试结果，使得结果易于阅读和比较。
# 这段代码定义了一个名为 generate_results_dict 的静态方法，它生成一个包含模型性能分析结果的字典。
# @staticmethod 装饰器表示这个方法是一个静态方法，不依赖于类的实例或类本身，可以不需要创建对象直接通过类来调用。
@staticmethod
# 方法接受四个参数。
# 1.model_name ：模型的名称。
# 2.t_onnx ：ONNX 模型的推理时间统计，包含平均时间。
# 3.t_engine ：TensorRT 引擎模型的推理时间统计，包含平均时间。
# 4.model_info ：模型的信息元组，包含层数、参数数量、梯度数量和浮点运算次数（FLOPs）。
def generate_results_dict(model_name, t_onnx, t_engine, model_info):
# 生成包括模型名称、参数、GFLOP 和速度指标的分析结果词典。
"""Generates a dictionary of profiling results including model name, parameters, GFLOPs, and speed metrics."""
# 从 model_info 元组中解包模型信息，分别赋值给 layers （层数） 、 params （参数数量） 、 gradients （梯度数量） 和 flops （浮点运算次数） 。
layers, params, gradients, flops = model_info
# 返回一个字典，包含以下键值对 ：
# "model/name" ：模型的名称。
# "model/parameters" ：模型的参数数量。
# "model/GFLOPs" ：模型的浮点运算次数，保留三位小数。
# "model/speed_ONNX(ms)" ：ONNX 模型的平均推理时间，保留三位小数，单位为毫秒。
# "model/speed_TensorRT(ms)" ：TensorRT 引擎模型的平均推理时间，保留三位小数，单位为毫秒。
return {
"model/name": model_name,
"model/parameters": params,
"model/GFLOPs": round(flops, 3),
"model/speed_ONNX(ms)": round(t_onnx[0], 3),
"model/speed_TensorRT(ms)": round(t_engine[0], 3),
}
# 这个方法提供了一个简洁的方式来组织和返回模型性能分析的结果。通过这种方式，可以方便地访问和比较不同模型的性能指标，例如推理速度和计算复杂度。生成的字典可以用于报告、存储或进一步的数据分析。
# 这段代码定义了一个名为 print_table 的静态方法，用于打印格式化的表格，展示模型性能分析的结果，包括速度和准确性指标。
# @staticmethod 装饰器表示这个方法是一个静态方法，不依赖于类的实例或类本身，可以不需要创建对象直接通过类来调用。
@staticmethod
# 方法接受一个参数。
# 1.table_rows ：这是一个包含表格行的字符串列表。
def print_table(table_rows):
# 打印模型分析结果的格式化表格，包括速度和准确性指标。
"""Prints a formatted table of model profiling results, including speed and accuracy metrics."""
# 检查是否有可用的 CUDA 设备（GPU），如果有，则获取第一个 CUDA 设备的名称；如果没有，则设置为 "GPU"。
gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU"
# 定义表格的标题行，包含 模型名称 、 图像尺寸 、 mAP 、 CPU 和 ONNX 的速度 、 TensorRT 的速度 、 参数数量 和 FLOPs。
# 这里使用了 HTML 风格的标签来格式化表格，例如 <br> 用于换行， <sup> 用于上标。
headers = [
"Model",
"size<br><sup>(pixels)",
"mAP<sup>val<br>50-95",
f"Speed<br><sup>CPU ({get_cpu_info()}) ONNX<br>(ms)",
f"Speed<br><sup>{gpu} TensorRT<br>(ms)",
"params<br><sup>(M)",
"FLOPs<br><sup>(B)",
]
# 创建表格的头部和分隔线。头部由表格标题组成，每个标题之间用 | 分隔。分隔线由相同数量的 - 字符组成，用于创建表格的边框。
header = "|" + "|".join(f" {h} " for h in headers) + "|"
separator = "|" + "|".join("-" * (len(h) + 2) for h in headers) + "|"
# 打印表格的头部和分隔线，以创建表格的顶部结构。
print(f"\n\n{header}")
print(separator)
# 遍历 table_rows 列表，打印每一行表格数据。
for row in table_rows:
print(row)
# 这个方法提供了一个格式化的方式来打印模型性能分析的结果，使得结果易于阅读和比较。通过这种方式，可以清晰地展示不同模型在不同硬件和软件配置下的性能表现。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
