validator.py
ultralytics\engine\validator.py
目录
1.所需的库和模块
# Ultralytics YOLO 🚀, AGPL-3.0 license
# 检查模型在数据集的测试或验证分割上的准确性。
# 用法 - 格式：
# yolo mode=val model=yolov8n.pt # PyTorch
"""
Check a model's accuracy on a test or val split of a dataset.
Usage:
$ yolo mode=val model=yolov8n.pt data=coco8.yaml imgsz=640
Usage - formats:
$ yolo mode=val model=yolov8n.pt # PyTorch
yolov8n.torchscript # TorchScript
yolov8n.onnx # ONNX Runtime or OpenCV DNN with dnn=True
yolov8n_openvino_model # OpenVINO
yolov8n.engine # TensorRT
yolov8n.mlpackage # CoreML (macOS-only)
yolov8n_saved_model # TensorFlow SavedModel
yolov8n.pb # TensorFlow GraphDef
yolov8n.tflite # TensorFlow Lite
yolov8n_edgetpu.tflite # TensorFlow Edge TPU
yolov8n_paddle_model # PaddlePaddle
yolov8n_ncnn_model # NCNN
"""
import json
import time
from pathlib import Path
import numpy as np
import torch
from ultralytics.cfg import get_cfg, get_save_dir
from ultralytics.data.utils import check_cls_dataset, check_det_dataset
from ultralytics.nn.autobackend import AutoBackend
from ultralytics.utils import LOGGER, TQDM, callbacks, colorstr, emojis
from ultralytics.utils.checks import check_imgsz
from ultralytics.utils.ops import Profile
from ultralytics.utils.torch_utils import de_parallel, select_device, smart_inference_mode2.class BaseValidator:
# 这段代码定义了一个名为 BaseValidator 的类，这个类是用于验证（或测试）模型性能的基类。
class BaseValidator:
# 用于创建验证器的基类。
"""
BaseValidator.
A base class for creating validators.
Attributes:
args (SimpleNamespace): Configuration for the validator.
dataloader (DataLoader): Dataloader to use for validation.
pbar (tqdm): Progress bar to update during validation.
model (nn.Module): Model to validate.
data (dict): Data dictionary.
device (torch.device): Device to use for validation.
batch_i (int): Current batch index.
training (bool): Whether the model is in training mode.
names (dict): Class names.
seen: Records the number of images seen so far during validation.
stats: Placeholder for statistics during validation.
confusion_matrix: Placeholder for a confusion matrix.
nc: Number of classes.
iouv: (torch.Tensor): IoU thresholds from 0.50 to 0.95 in spaces of 0.05.
jdict (dict): Dictionary to store JSON validation results.
speed (dict): Dictionary with keys 'preprocess', 'inference', 'loss', 'postprocess' and their respective
batch processing times in milliseconds.
save_dir (Path): Directory to save results.
plots (dict): Dictionary to store plots for visualization.
callbacks (dict): Dictionary to store various callback functions.
"""
# 这是 BaseValidator 类的构造函数（ __init__ ），它初始化了类的实例变量，并设置了一些默认值，它接受五个参数。
# 1.dataloader ：可能用于加载数据的迭代器。
# 2.save_dir ：保存验证结果的目录。
# 3.pbar ：进度条对象，用于显示验证进度。
# 4.args ：配置参数，可能是一个字典或对象，包含模型配置。
# 5._callbacks ：回调函数列表，用于在验证过程中的特定事件触发时执行。
def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
# 初始化 BaseValidator 实例。
"""
Initializes a BaseValidator instance.
Args:
dataloader (torch.utils.data.DataLoader): Dataloader to be used for validation.
save_dir (Path, optional): Directory to save results.
pbar (tqdm.tqdm): Progress bar for displaying progress.
args (SimpleNamespace): Configuration for the validator.
_callbacks (dict): Dictionary to store various callback functions.
"""
# 这段代码是 BaseValidator 类的构造函数的一部分，它负责初始化类的属性。
# 调用 get_cfg 函数来获取配置，并使用 args 参数中的值来覆盖默认配置。
# def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None):
# -> 从一个配置源（可以是字符串、路径、字典或 SimpleNamespace 对象）获取配置，并允许通过 overrides 字典来覆盖默认配置。返回一个 IterableSimpleNamespace 对象，它是一个可迭代的命名空间对象，其属性由 cfg 字典中的键值对初始化。
# -> return IterableSimpleNamespace(**cfg)
self.args = get_cfg(overrides=args)
# 将传入的 dataloader 参数赋值给类的实例变量 dataloader 。 dataloader 通常用于在深度学习中加载和迭代数据集。
self.dataloader = dataloader
# 将传入的 pbar 参数赋值给类的实例变量 pbar 。 pbar 是指一个进度条对象，用于显示数据处理的进度。
self.pbar = pbar
# 初始化 stride 属性为 None 。在图像处理或模型训练中， stride 指的是步长。
self.stride = None
# 初始化 data 属性为 None 。这个属性用于存储当前处理的数据。
self.data = None
# 初始化 device 属性为 None 。这个属性用于存储模型运行的设备信息，比如CPU或GPU。
self.device = None
# 初始化 batch_i 属性为 None 。这个属性用于跟踪当前处理的批次索引。
self.batch_i = None
# 初始化 training 属性为 True 。这个属性用于指示当前模式是训练模式。
self.training = True
# 初始化 names 属性为 None 。这个属性用于存储类别名称或其他名称。
self.names = None
# 初始化 seen 属性为 None 。这个属性用于跟踪模型已经看到的样本数量。
self.seen = None
# 初始化 stats 属性为 None 。这个属性用于存储统计信息，比如准确率、损失值等。
self.stats = None
# 初始化 confusion_matrix 属性为 None 。这个属性用于存储混淆矩阵，用于评估分类模型的性能。
self.confusion_matrix = None
# 初始化 nc 属性为 None 。这个属性是 number of classes 的缩写，用于存储类别的数量。
self.nc = None
# 初始化 iouv 属性为 None 。用于存储IoU（交并比）相关的数据。
self.iouv = None
# 初始化 jdict 属性为 None 。这个属性是一个字典，用于存储与模型评估相关的数据。
self.jdict = None
# 初始化 speed 属性为一个字典，包含四个键，分别对应 预处理 、 推理 、 损失计算 和 后处理 的速度，初始值都设置为0.0。
self.speed = {"preprocess": 0.0, "inference": 0.0, "loss": 0.0, "postprocess": 0.0}
# 这些属性为 BaseValidator 类提供了一个框架，以便在验证过程中存储和管理各种信息。具体的实现细节和用途将取决于类的其他方法和上下文环境。
# 这段代码是 BaseValidator 类构造函数的一部分，它负责设置保存目录、配置参数、回调函数和绘图数据。
# 设置了 self.save_dir 属性，它表示模型验证结果的保存目录。
# 如果 save_dir 参数被传入，则使用这个值；如果没有传入（即 save_dir 为 None ），则调用 get_save_dir 函数，根据 self.args 中的配置参数来获取一个默认的保存目录。
# # def get_save_dir(args, name=None): -> 获取或创建一个用于保存特定数据（如模型权重、日志等）的目录路径。返回保存目录的路径。返回一个 Path 对象，表示保存目录的路径。 -> return Path(save_dir)
self.save_dir = save_dir or get_save_dir(self.args)
# 确保 self.save_dir 目录存在，如果 self.args.save_txt 为 True ，则在 self.save_dir 下创建一个名为 labels 的子目录。
# mkdir 函数的 parents=True 参数表示如果父目录不存在，则创建父目录。
# exist_ok=True 参数表示如果目录已经存在，则不抛出异常。
(self.save_dir / "labels" if self.args.save_txt else self.save_dir).mkdir(parents=True, exist_ok=True)
# 检查 self.args.conf 是否为 None ，如果是，则将其设置为默认的置信度阈值0.001。 self.args.conf 用于后续的模型验证过程中，作为判断预测结果是否可信的依据。
if self.args.conf is None:
self.args.conf = 0.001 # default conf=0.001
# 调用 check_imgsz 函数来检查或调整 self.args.imgsz 的值，确保图像尺寸是有效的。 max_dim=1 参数表示图像的最大维度限制。
# def check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0): -> 用于检查和调整图像尺寸（ imgsz ），以确保它们符合特定的要求。返回调整后的图像尺寸。 -> return sz
self.args.imgsz = check_imgsz(self.args.imgsz, max_dim=1)
# 初始化一个空字典 self.plots ，用于存储绘图相关的数据。
self.plots = {}
# 设置了 self.callbacks 属性，它表示在验证过程中需要调用的回调函数列表。
# 如果 _callbacks 参数被传入，则使用这个值；如果没有传入（即 _callbacks 为 None ），则调用 callbacks.get_default_callbacks 函数获取默认的回调函数列表。
# def get_default_callbacks():
# -> 返回默认的回调函数列表。这行代码返回一个 defaultdict 对象，它使用 list 作为默认工厂函数，这意味着如果访问的键不存在，将会创建一个空列表作为该键的值。
# -> return defaultdict(list, deepcopy(default_callbacks))
self.callbacks = _callbacks or callbacks.get_default_callbacks()
# 这段代码的主要作用是确保 BaseValidator 类的实例在创建时已经配置好了所有必要的参数和目录，以便在后续的验证过程中能够顺利执行。
# 这个构造函数为 BaseValidator 类提供了一个全面的初始化过程，确保所有必要的变量都已设置并准备好用于后续的验证过程。
# 这段代码是 BaseValidator 类的核心方法 __call__ ，它定义了验证过程的执行流程。这个方法被设计为可重入的，能够根据是否传入 trainer 参数来决定是执行训练模式下的验证还是单独的验证。
# 方法签名。
# @smart_inference_mode() ：这是一个装饰器，可能用于设置或优化推理模式。
# def smart_inference_mode():
# -> 根据 PyTorch 的版本动态地选择使用 torch.inference_mode() 装饰器或 torch.no_grad() 装饰器。smart_inference_mode 函数返回 decorate 函数，这意味着 decorate 本身是一个装饰器，它可以根据 PyTorch 的版本和推理模式的状态来动态地装饰其他函数。
# -> return decorate
@smart_inference_mode()
# 1.trainer ：训练器对象，如果提供了这个参数， __call__ 方法将在训练模式下执行。
# 2.model ：模型对象，如果提供了这个参数，将用于推理。
def __call__(self, trainer=None, model=None):
# 执行验证过程，在数据加载器上运行推理并计算性能指标。
"""Executes validation process, running inference on dataloader and computing performance metrics."""
# 这段代码是 BaseValidator 类的 __call__ 方法的一部分，它处理在训练模式下的验证过程。
# 设置了一个标志 self.training ，如果 trainer 对象不为 None ，则设置为 True ，表示当前处于 训练模式 下的验证。
self.training = trainer is not None
# 根据配置 self.args.augment 和训练模式标志 self.training 来决定是否进行数据增强。如果配置了数据增强且当前不在训练模式下，则 augment 为 True 。
augment = self.args.augment and (not self.training)
# 这是一个条件判断，如果当前是训练模式，则执行下面的代码块。
if self.training:
# 设置当前设备的 self.device 属性，从 trainer 对象中获取。
self.device = trainer.device
# 设置当前数据的 self.data 属性，从 trainer 对象中获取。
self.data = trainer.data
# force FP16 val during training
# 设置 self.args.half 属性，如果设备不是CPU且 trainer 对象支持自动混合精度（AMP），则启用半精度（FP16）。
self.args.half = self.device.type != "cpu" and trainer.amp
# 获取模型，优先使用指数移动平均（EMA）模型，如果没有EMA，则使用 trainer 对象中的模型。
model = trainer.ema.ema or trainer.model
# 根据 self.args.half 的值，将模型设置为半精度（FP16）或单精度（FP32）。
model = model.half() if self.args.half else model.float()
# self.model = model
# 初始化损失值 self.loss ，它是一个与 trainer.loss_items 形状相同且在相同设备上的零张量。
self.loss = torch.zeros_like(trainer.loss_items, device=trainer.device)
# 更新 self.args.plots 属性，如果训练停止条件可能被触发或当前是最后一个训练周期，则保留绘图标志。
self.args.plots &= trainer.stopper.possible_stop or (trainer.epoch == trainer.epochs - 1)
# 将模型设置为评估模式，这会关闭 Dropout 和 Batch Normalization 等训练特有的行为。
model.eval()
# 这段代码的主要作用是为训练模式下的验证过程做准备，包括设置设备、数据、模型和损失计算，并确保模型处于评估模式。
# 这段代码是 BaseValidator 类的 __call__ 方法中处理非训练模式（即单独验证模式）的部分。
# 这个 else 块与之前的 if self.training: 块相对应，表示如果不在训练模式下，执行以下代码。
else:
# 为当前验证器实例添加集成回调函数。这些回调函数可能用于在验证过程中的不同阶段执行特定的操作。
# def add_integration_callbacks(instance): -> 向一个实例添加集成的回调函数。这些回调函数通常用于训练过程中的不同阶段，例如记录训练日志、跟踪实验进度等。
callbacks.add_integration_callbacks(self)
# 创建一个 AutoBackend 实例，它是一个自动选择后端的模型加载器。这里传入了模型权重、设备、DNN设置、数据路径、以及是否使用半精度计算等参数。
# class AutoBackend(nn.Module):
# -> AutoBackend 的类，它是 torch.nn.Module 的子类。处理使用 Ultralytics YOLO 模型运行推理的动态后端选择。
# -> def __init__(self, weights="yolov8n.pt", device=torch.device("cpu"), dnn=False, data=None, fp16=False, batch=1, fuse=True, verbose=True,):
model = AutoBackend(
# 如果传入了 model 参数，则使用它；否则，使用 self.args.model 中指定的模型权重。
weights=model or self.args.model,
# 根据配置选择设备。
# def select_device(device="", batch=0, newline=False, verbose=True):
# -> 用于根据用户提供的设备字符串选择并返回一个合适的 PyTorch 设备对象。返回设备对象。返回一个 PyTorch 设备对象，可以是 GPU、MPS 或 CPU。
# -> return torch.device(arg)
device=select_device(self.args.device, self.args.batch),
# 是否使用DNN（深度神经网络）设置。
dnn=self.args.dnn,
# 数据路径。
data=self.args.data,
# 是否使用半精度（FP16）计算。
fp16=self.args.half,
)
# self.model = model
# 更新 self.device 属性，使其与 AutoBackend 实例使用的设备相匹配。
self.device = model.device # update device
# 更新 self.args.half 属性，使其与 AutoBackend 实例的半精度设置相匹配。
self.args.half = model.fp16 # update half
# 从 AutoBackend 实例中提取 步长 （stride） 、 PyTorch （pt） 、 Just-In-Time （jit） 编译 和 引擎 （engine） 设置 。
stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
# 调用 check_imgsz 函数来检查或调整图像尺寸，考虑到步长的影响。
imgsz = check_imgsz(self.args.imgsz, stride=stride)
# 如果使用了引擎（如TensorRT），则根据模型的批处理大小设置 self.args.batch 。
if engine:
self.args.batch = model.batch_size
# JIT编译（Just-In-Time Compilation）是一种编译技术，它在程序运行时将高级语言代码（通常是中间代码或字节码）转换成机器码。这种编译方式的主要目的是提高程序的执行效率，特别是在那些需要动态执行代码的场景中。
# JIT编译是一种强大的技术，它使得程序能够在保持灵活性的同时提高执行效率，特别是在那些需要动态执行代码的应用程序中。
# 如果没有使用PyTorch或JIT编译，且不是引擎模式，则从模型的元数据中获取默认的批处理大小，并设置 self.args.batch 。
elif not pt and not jit:
self.args.batch = model.metadata.get("batch", 1) # export.py models default to batch-size 1
# 使用 LOGGER 记录当前设置的批处理大小和输入图像的形状。
LOGGER.info(f"Setting batch={self.args.batch} input of shape ({self.args.batch}, 3, {imgsz}, {imgsz})") # 设置 batch={self.args.batch} 形状输入 ({self.args.batch}, 3, {imgsz}, {imgsz})。
# 这段代码的主要作用是在非训练模式下初始化验证过程，包括设置回调函数、加载模型、选择设备、调整图像尺寸和批处理大小等。这些步骤为后续的验证和推理提供了必要的准备。
# 这段代码是 BaseValidator 类的 __call__ 方法中的一部分，它处理数据集的加载、设备设置、数据加载器的初始化以及模型的预热。
# 检查 self.args.data 的文件扩展名是否为 .yaml 或 .yml 。如果是，表示这是一个配置文件，通常用于指定数据集的路径和其他设置。
if str(self.args.data).split(".")[-1] in {"yaml", "yml"}:
# 如果上一行的条件为真，这行代码调用 check_det_dataset 函数来加载和验证检测任务的数据集。这个函数会检查数据集的完整性，并返回一个数据集对象。
# def check_det_dataset(dataset, autodownload=True):
# -> 检查和处理数据集（dataset），确保数据集的YAML配置文件符合要求，并在需要时下载数据集。函数返回处理后的 data 字典，其中包含了 数据集的 配置信息 和 路径 。
# -> return data # dictionary
self.data = check_det_dataset(self.args.data)
# 如果 self.args.data 不是 .yaml 或 .yml 文件，代码检查任务类型是否为分类（"classify"）。
elif self.args.task == "classify":
# 如果任务类型为分类，这行代码调用 check_cls_dataset 函数来加载和验证分类任务的数据集，并根据 self.args.split 参数指定的数据集分割（如训练集、验证集或测试集）。
# def check_cls_dataset(dataset, split=""):
# -> 检查分类数据集的完整性，并在必要时下载数据集。函数返回一个字典，包含 训练集 、 验证集 和 测试集 的 路径 、 类别数量 和 类别名称 。
# -> return {"train": train_set, "val": val_set, "test": test_set, "nc": nc, "names": names}
self.data = check_cls_dataset(self.args.data, split=self.args.split)
# 如果以上条件都不满足，执行这个 else 块。
else:
# 如果没有找到匹配的数据集，抛出 FileNotFoundError 异常，并显示一个带有emoji的错误消息，指出数据集未找到。
raise FileNotFoundError(emojis(f"Dataset '{self.args.data}' for task={self.args.task} not found ❌")) # 未找到 task={self.args.task} 的数据集 '{self.args.data}' ❌。
# 查设备类型是否为CPU或MPS（苹果的Metal Performance Shaders）。
if self.device.type in {"cpu", "mps"}:
# 如果设备是CPU或MPS，将 self.args.workers 设置为0。这意味着在CPU验证时，不使用额外的工作线程来加载数据，因为CPU推理的时间通常比数据加载的时间要长。
self.args.workers = 0 # faster CPU val as time dominated by inference, not dataloading
# 这行代码检查是否不使用PyTorch（ pt 为 False ）。
if not pt:
# 如果不使用PyTorch，将 self.args.rect 设置为 False ，表示不使用矩形坐标。
self.args.rect = False
# 这行代码将模型的步长（ stride ）赋值给 self.stride ，这个值可能用于后续的数据加载器中，用于图像的填充。
self.stride = model.stride # used in get_dataloader() for padding
# 如果 self.dataloader 已经被设置，则使用它；否则，调用 get_dataloader 函数来创建一个新的数据加载器，并传入分割后的数据集和批处理大小。
self.dataloader = self.dataloader or self.get_dataloader(self.data.get(self.args.split), self.args.batch)
# 将模型设置为评估模式，这会关闭Dropout和Batch Normalization等训练特有的行为。
model.eval()
# 对模型进行预热，传入一个包含批处理大小、通道数和图像尺寸的元组。如果使用PyTorch，批处理大小为1；否则，使用 self.args.batch 指定的批处理大小。预热有助于提高模型推理时的性能。
model.warmup(imgsz=(1 if pt else self.args.batch, 3, imgsz, imgsz)) # warmup
# 这段代码的主要作用是确保数据集被正确加载和验证，设备设置被正确应用，数据加载器被创建，以及模型被正确设置为评估模式并进行预热，为后续的验证和推理做好准备。
# 这段代码继续描述了 BaseValidator 类的 __call__ 方法中的操作，涉及到回调函数的执行、性能分析工具的初始化、进度条的设置、度量指标的初始化以及准备用于存储结果的数据结构。
# 调用 run_callbacks 方法，并传入字符串 "on_val_start" 作为参数。这通常意味着在验证过程开始之前，执行所有注册到 "on_val_start" 事件的回调函数。
self.run_callbacks("on_val_start")
# 创建了四个 Profile 对象的元组。每个 Profile 对象都用于性能分析，监控不同阶段（如预处理、推理、损失计算和后处理）的时间消耗。 device=self.device 参数指定了性能分析应该在哪个设备上进行，通常是模型运行的设备。
# class Profile(contextlib.ContextDecorator):
# -> 它是一个上下文管理器（使用 contextlib.ContextDecorator ），用于测量代码块的执行时间。
# -> def __init__(self, t=0.0, device: torch.device = None):
dt = (
Profile(device=self.device),
Profile(device=self.device),
Profile(device=self.device),
Profile(device=self.device),
)
# 创建了一个 TQDM 进度条对象 bar ，用于显示数据加载器 self.dataloader 的进度。 desc 参数提供了进度条的描述，由 self.get_desc() 方法返回。 total 参数设置了进度条的总步数，通常等于数据加载器中的批次总数。
bar = TQDM(self.dataloader, desc=self.get_desc(), total=len(self.dataloader))
# 调用 init_metrics 方法来初始化度量指标。 de_parallel(model) 是一个函数，用于去除模型的并行包装（如果模型被包装在如 torch.nn.DataParallel 或 torch.nn.parallel.DistributedDataParallel 中），以获取原始模型实例。这样可以确保度量指标是基于原始模型计算的。
# def de_parallel(model): -> 将一个可能处于数据并行（DataParallel）或分布式数据并行（DistributedDataParallel，简称 DDP）状态的模型转换回单GPU模型。 -> return model.module if is_parallel(model) else model
self.init_metrics(de_parallel(model))
# 初始化一个空列表 self.jdict 。这个列表用于存储验证过程中的中间结果或最终结果，以便后续处理或保存。
self.jdict = [] # empty before each val
# 这段代码的主要作用是为验证过程的执行做准备，包括设置回调函数、性能分析工具、进度条和度量指标的初始化，以及准备用于存储结果的数据结构。这些步骤为后续的验证和推理提供了必要的支持和反馈机制。
# 这段代码是 BaseValidator 类的 __call__ 方法中的核心循环，它遍历数据加载器中的每个批次，并执行一系列的操作，包括回调函数的触发、预处理、推理、损失计算、后处理、度量指标更新以及结果绘图。
# 开始一个循环，遍历 bar （一个 TQDM 进度条对象，包装了 self.dataloader ）。 batch_i 是批次索引， batch 是当前批次的数据。
for batch_i, batch in enumerate(bar):
# 在处理每个批次之前，调用 run_callbacks 方法，触发所有注册为 "on_val_batch_start" 事件的回调函数。
self.run_callbacks("on_val_batch_start")
# 更新 self.batch_i 属性，记录当前的批次索引。
self.batch_i = batch_i
# Preprocess 表示接下来的代码块将执行数据的预处理操作。
# 使用 Profile 对象 dt[0] 来记录预处理阶段的时间消耗。
with dt[0]:
# 调用 self.preprocess 方法对当前批次的数据进行预处理，并将处理后的数据重新赋值给 batch 。
batch = self.preprocess(batch)
# Inference 表示接下来的代码块将执行模型推理操作。
# 使用 Profile 对象 dt[1] 来记录推理阶段的时间消耗。
with dt[1]:
# 调用模型的推理方法，传入预处理后的图像数据 batch["img"] 和是否进行数据增强的标志 augment ，得到预测结果 preds 。
preds = model(batch["img"], augment=augment)
# Loss 表示接下来的代码块将执行损失计算操作。
# 使用 Profile 对象 dt[2] 来记录损失计算阶段的时间消耗。
with dt[2]:
# 如果当前处于训练模式（即 self.training 为 True ），则执行以下代码。
if self.training:
# 调用模型的损失计算方法，传入批次数据和预测结果，并将计算得到的损失累加到 self.loss 。
self.loss += model.loss(batch, preds)[1]
# Postprocess 表示接下来的代码块将执行后处理操作。
# 使用 Profile 对象 dt[3] 来记录后处理阶段的时间消耗。
with dt[3]:
# 调用 self.postprocess 方法对预测结果进行后处理，并将处理后的结果重新赋值给 preds 。
preds = self.postprocess(preds)
# 调用 self.update_metrics 方法，根据预测结果和批次数据更新度量指标。
self.update_metrics(preds, batch)
# 如果配置了绘图（ self.args.plots 为 True ）且当前批次索引小于3，则执行以下代码。
if self.args.plots and batch_i < 3:
# 调用 self.plot_val_samples 方法，绘制验证样本。
self.plot_val_samples(batch, batch_i)
# 调用 self.plot_predictions 方法，绘制预测结果。
self.plot_predictions(batch, preds, batch_i)
# 在处理完每个批次之后，调用 run_callbacks 方法，触发所有注册为 "on_val_batch_end" 事件的回调函数。
self.run_callbacks("on_val_batch_end")
# 这个循环是验证过程中的核心，它确保每个批次的数据都被正确地处理，并且相关的性能指标被更新。通过回调函数，可以在每个批次的开始和结束时执行额外的操作，增加了代码的灵活性和扩展性。
# 这段代码是 BaseValidator 类的 __call__ 方法中的最后部分，它处理验证过程结束后的一系列操作，包括获取统计数据、检查统计数据、计算速度、最终确定度量指标、打印结果以及触发验证结束的回调函数。
# 调用 self.get_stats 方法来获取当前的统计数据，这些数据包括准确率、损失值等度量指标。
stats = self.get_stats()
# 调用 self.check_stats 方法来检查获取到的统计数据 stats ，这个方法会验证数据的完整性和有效性。
self.check_stats(stats)
# 这行代码计算整个验证过程的速度。它使用 zip 函数将 self.speed 的键（即"preprocess"、"inference"、"loss"、"postprocess"）与对应的时间消耗（以毫秒为单位）配对，形成一个新的字典。
# x.t 是 Profile 对象记录的时间消耗， len(self.dataloader.dataset) 是数据集中的数据点总数， 1e3 是将时间从秒转换为毫秒。
self.speed = dict(zip(self.speed.keys(), (x.t / len(self.dataloader.dataset) * 1e3 for x in dt)))
# 调用 self.finalize_metrics 方法来最终确定度量指标，这包括计算平均值、百分比或其他统计操作。
self.finalize_metrics()
# 调用 self.print_results 方法来打印验证结果，这包括在控制台输出统计数据和其他相关信息。
self.print_results()
# 调用 run_callbacks 方法，并传入字符串 "on_val_end" 作为参数。这个方法会触发所有注册为 "on_val_end" 事件的回调函数，这些回调函数通常在验证过程结束时执行。
self.run_callbacks("on_val_end")
# 这段代码的主要作用是完成验证过程的收尾工作，确保所有的统计数据都被正确计算和报告，并且通过回调函数提供了扩展验证过程的机制。这些步骤对于评估模型的性能和调试模型至关重要。
# 这段代码是 BaseValidator 类的 __call__ 方法的最后部分，它根据是否处于训练模式来处理不同的返回逻辑。
# 训练模式下的处理。
# 这个条件判断检查是否处于训练模式。
if self.training:
# 如果处于训练模式，将模型的数据类型转换为单精度浮点数（float），以确保损失计算的精度。
model.float()
# 将统计数据 stats 和 trainer 对象计算的 损失项 合并到一个新的字典 results 中。这里 self.loss.cpu() 将损失数据移到CPU，然后除以数据加载器中的样本总数来计算平均损失。
results = {**stats, **trainer.label_loss_items(self.loss.cpu() / len(self.dataloader), prefix="val")}
# 返回一个新字典，其中包含 results 中的所有项，并将每个值四舍五入到五位小数。这是为了确保返回的结果具有一致的小数位数。
return {k: round(float(v), 5) for k, v in results.items()} # return results as 5 decimal place floats
# 非训练模式下的处理。
# 如果不在训练模式下，执行以下代码。
else:
# 使用 LOGGER 记录一个信息，显示每个阶段（ 预处理 、 推理 、 损失计算 、 后处理 ）的速度，单位为毫秒。
LOGGER.info(
"Speed: {:.1f}ms preprocess, {:.1f}ms inference, {:.1f}ms loss, {:.1f}ms postprocess per image".format(
*tuple(self.speed.values())
)
)
# 如果配置了保存JSON（ self.args.save_json 为 True ）并且 self.jdict 不为空，则执行以下代码。
if self.args.save_json and self.jdict:
# 打开一个文件 predictions.json 用于写入，文件路径由 self.save_dir 和文件名组成。
with open(str(self.save_dir / "predictions.json"), "w") as f:
# 记录一个信息，显示正在保存的文件名。
LOGGER.info(f"Saving {f.name}...") # 正在保存 {f.name}...
# 将 self.jdict 中的数据以JSON格式写入文件。
json.dump(self.jdict, f) # flatten and save
# 调用 self.eval_json 方法更新统计数据 stats ，基于 self.jdict 中的数据。
stats = self.eval_json(stats) # update stats
# 如果配置了 绘图 或 保存JSON ，则执行以下代码。
if self.args.plots or self.args.save_json:
# 记录一个信息，显示结果保存的位置，使用 colorstr 函数加粗显示目录路径。
LOGGER.info(f"Results saved to {colorstr('bold', self.save_dir)}") # 结果保存至 {colorstr('bold', self.save_dir)}。
# 返回最终的统计数据 stats 。
return stats
# 这段代码的主要作用是在验证过程结束后，根据是否处于训练模式来处理和返回结果。在训练模式下，它确保返回精确的损失和性能指标；在非训练模式下，它提供了结果的保存和记录功能。这些步骤对于监控模型性能和调试模型至关重要。
# 这个方法是验证流程的核心，它集成了数据加载、模型推理、性能分析和结果记录等多个步骤，确保了验证过程的完整性和灵活性。
# 这段代码定义了一个名为 match_predictions 的方法，它用于在目标检测任务中匹配预测结果和真实标签。这个方法的核心功能是确定预测的边界框与真实边界框之间的匹配关系，通常基于交并比（IoU）阈值。
# 方法签名。
# 1.self ：类的实例。
# 2.pred_classes ：预测的类别。
# 3.true_classes ：真实的类别。
# 4.iou ：预测边界框与真实边界框之间的交并比矩阵。
# 5.use_scipy ：一个布尔值，指示是否使用SciPy库来解决匹配问题。
def match_predictions(self, pred_classes, true_classes, iou, use_scipy=False):
# 使用 IoU 将预测与真实对象 (pred_classes、true_classes) 进行匹配。
"""
Matches predictions to ground truth objects (pred_classes, true_classes) using IoU.
Args:
pred_classes (torch.Tensor): Predicted class indices of shape(N,).
true_classes (torch.Tensor): Target class indices of shape(M,).
iou (torch.Tensor): An NxM tensor containing the pairwise IoU values for predictions and ground of truth
use_scipy (bool): Whether to use scipy for matching (more precise).
Returns:
(torch.Tensor): Correct tensor of shape(N,10) for 10 IoU thresholds.
"""
# Dx10 matrix, where D - detections, 10 - IoU thresholds Dx10 矩阵，其中 D - 检测，10 - IoU 阈值。
# 初始化一个全零的布尔矩阵 correct ，其行数等于预测的数量，列数等于IoU阈值的数量。
correct = np.zeros((pred_classes.shape[0], self.iouv.shape[0])).astype(bool)
# LxD matrix where L - labels (rows), D - detections (columns) LxD 矩阵，其中 L - 标签（行），D - 检测（列）。
# 创建一个布尔矩阵，表示真实类别和预测类别是否匹配。
correct_class = true_classes[:, None] == pred_classes
# 将IoU矩阵中的值与 类别匹配矩阵 相乘，以将不匹配的类别的IoU值置零。
iou = iou * correct_class # zero out the wrong classes
# 将IoU矩阵从GPU（如果适用）转移到CPU，并转换为NumPy数组。
iou = iou.cpu().numpy()
# 遍历每个IoU阈值。
for i, threshold in enumerate(self.iouv.cpu().tolist()):
# 这段代码是 match_predictions 方法中使用SciPy库进行最优匹配的部分。
# 这个条件判断检查是否选择使用SciPy库进行匹配。
if use_scipy:
# WARNING: known issue that reduces mAP in https://github.com/ultralytics/ultralytics/pull/4708 警告：已知问题会导致 https://github.com/ultralytics/ultralytics/pull/4708 中的 mAP 降低。
# 如果 use_scipy 为 True ，则在该作用域内导入SciPy库。这种导入方式称为“scope import”，它确保了SciPy库只在需要时才被导入，避免了在不需要时导入大型库，从而可能提高程序的启动速度。
import scipy # scope import to avoid importing for all commands
# 创建一个“成本矩阵”，其中元素为 iou 矩阵中大于或等于当前阈值 threshold 的值。这个矩阵将用于SciPy的线性求和分配算法。
cost_matrix = iou * (iou >= threshold)
# 检查成本矩阵中是否有任何非零元素。如果有，意味着存在可能的匹配。
if cost_matrix.any():
# scipy.optimize.linear_sum_assignment(cost_matrix, maximize=False)
# scipy.optimize.linear_sum_assignment() 是 SciPy 库中的一个函数，用于解决线性和分配问题，也称为二分图中的最小权重匹配问题。这个函数可以找到一个最优的分配方案，使得总成本最小化（或最大化）。
# 参数 ：
# cost_matrix ：一个二维数组（成本矩阵），表示二分图中各节点匹配的代价。
# maximize ：一个布尔值，默认为 False 。如果设置为 True ，则计算最大权重匹配；如果为 False ，则计算最小权重匹配。
# 返回值 ：
# row_ind ：一个数组，包含最优分配方案中行的索引。
# col_ind ：一个数组，包含最优分配方案中列的索引。
# 这两个数组一起给出了成本矩阵中每一行与每一列的最优匹配。分配的成本可以通过 cost_matrix[row_ind, col_ind].sum() 计算得出。如果成本矩阵是方阵，返回的行索引将被排序，并且等于 numpy.arange(cost_matrix.shape[0]) 。
# 说明 ：
# 线性和分配问题在二分图中也称为最小权重匹配。问题实例由矩阵 C 描述，其中每个 C[i,j] 是匹配第一个部分集合的顶点 i 和第二个集合的顶点 j 的成本。目标是找到一个完整的分配，使得总成本最小化。
# 形式上，让 X 是一个布尔矩阵，其中 X[i,j] = 1 表示行 i 分配给列 j 。那么最优分配的成本为 ：
# min∑i∑jCijXij
# 其中，在矩阵 X 为方阵的情况下，每一行恰好分配给一列，每一列恰好分配给一行。
# 该函数还可以解决成本矩阵为矩形的经典分配问题的推广。如果它有比列数多的行数，则不需要将每一行都分配给一列，反之亦然。
# 这个实现是修改的 Jonker-Volgenant 算法，没有初始化。
# 使用SciPy的 linear_sum_assignment 函数找到成本矩阵中的最大权重匹配。这个函数解决的是线性分配问题，即如何将两个集合中的元素配对以最大化总权重。 maximize=True 参数表示我们希望最大化总权重。
labels_idx, detections_idx = scipy.optimize.linear_sum_assignment(cost_matrix, maximize=True)
# 创建一个布尔数组 valid ，表示找到的匹配是否有效。如果匹配的成本（即IoU值）大于0，则认为匹配有效。
valid = cost_matrix[labels_idx, detections_idx] > 0
# 检查是否有任何有效的匹配。
if valid.any():
# 将有效匹配的预测标记为正确。这里 detections_idx[valid] 是有效匹配的预测索引， i 是当前的IoU阈值索引。
correct[detections_idx[valid], i] = True
# 这段代码使用SciPy库的线性求和分配算法来找到最优的预测和真实标签之间的匹配，这通常用于目标检测任务中，以确定预测的边界框与真实边界框之间的最佳匹配。这种方法特别适用于处理多个预测边界框与多个真实边界框之间的匹配问题，尤其是在预测数量与真实标签数量不一致时。
# 这段代码是 match_predictions 方法中不使用SciPy库时的匹配逻辑。
# 这个 else 块与前面的 if use_scipy: 块相对应，表示如果不使用SciPy库，则执行这里的代码。
else:
# numpy.nonzero(a, size=None)
# np.nonzero() 是 NumPy 库中的一个函数，它返回输入数组中非零元素的索引。这个函数对于找出数组中满足特定条件的元素位置非常有用，尤其是在处理条件过滤和索引操作时。
# 参数 ：
# a ：输入的数组。
# size ：一个整数或整数元组。如果提供，输出数组的大小将被修改以匹配这个参数。这个参数主要用于兼容旧版本的 NumPy。
# 返回值 ：
# np.nonzero() 返回一个元组，其中包含输入数组中非零元素的索引数组。每个索引数组对应输入数组的一个维度。
# 如果输入数组是一维的，返回的是一个包含索引的单个数组。
# 如果输入数组是多维的，返回的是与输入数组维度相同数量的数组，每个数组包含对应维度上的索引。
# 使用NumPy的 nonzero 函数找到所有IoU值大于或等于当前阈值 threshold 的索引。这将返回两个数组，分别对应 行索引 和 列索引 。
matches = np.nonzero(iou >= threshold) # IoU > threshold and classes match
# 将 nonzero 函数返回的两个数组转换为一个NumPy数组，并转置它，使得 每一行 代表 一个匹配的索引对 。
matches = np.array(matches).T
# 检查是否有任何匹配的索引对。
if matches.shape[0]:
# 如果匹配的索引对数量大于1，即存在多个匹配，需要进一步处理。
if matches.shape[0] > 1:
# 根据IoU值对匹配的索引对进行降序排序，选择IoU值最高的匹配。
# matches[:, 0] 和 matches[:, 1] 分别是 matches 数组中的行索引和列索引，它们指向 iou 矩阵中的具体元素。
# .argsort()[::-1] ： argsort() 函数返回的是数组元素从小到大排序后的索引值。 [::-1] 是一个切片操作，它将 argsort() 的结果进行反转，从而实现降序排序。
# 这个表达式使用 argsort() 返回的索引来对 matches 数组进行索引，从而选择出IoU值最高的匹配。 由于 [::-1] 的作用，选择的是IoU值最高的匹配，即最匹配的预测和真实边界框。
matches = matches[iou[matches[:, 0], matches[:, 1]].argsort()[::-1]]
# 去除重复的预测索引，确保每个预测只被匹配一次。
matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
# matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
# 将匹配的预测标记为正确。这里 matches[:, 1] 是预测的索引， i 是当前的IoU阈值索引。
correct[matches[:, 1].astype(int), i] = True
# 返回一个布尔张量，表示预测是否正确，数据类型为布尔，设备与 pred_classes 相同。
# 这段代码的逻辑是 ：
# 首先，找到所有IoU值大于或等于阈值的匹配。 然后，如果有多个匹配，根据IoU值进行排序，选择最佳的匹配。 最后，去除重复的预测索引，确保每个预测只被匹配一次，并标记这些匹配为正确。
# 这种方法不依赖于SciPy库，使用NumPy的基本功能来实现匹配逻辑，适用于IoU阈值匹配问题，尤其是在预测数量和真实标签数量相等或预测数量较少时。
return torch.tensor(correct, dtype=torch.bool, device=pred_classes.device)
# 这个方法是目标检测评估流程中的关键步骤，它通过比较预测结果和真实标签来确定检测的准确性。使用SciPy库可以提高匹配的效率，但可能会影响mAP（平均精度均值）的计算，如PR中提到的已知问题。
# 这段代码定义了一个名为 add_callback 的方法，它用于向一个事件添加回调函数。这个方法是类的一个成员方法，通常用在支持事件驱动编程的类中。
# 方法签名。
# 1.self ：类的实例。
# 2.event ：事件的名称，这是一个字符串参数，表示将要触发的事件。
# 3.callback ：回调函数，这是一个函数或可调用对象，当指定的事件被触发时执行。
def add_callback(self, event: str, callback):
# 附加给定的回调。
"""Appends the given callback."""
# self.callbacks 是一个字典，用于存储与特定事件相关联的回调函数列表。
# self.callbacks[event] 访问与特定事件 event 相关联的回调函数列表。
# append(callback) 是一个列表方法，用于将新的回调函数 callback 添加到该事件的回调函数列表中。
self.callbacks[event].append(callback)
# 这个方法允许用户为特定的事件添加回调函数。当事件被触发时，所有注册到该事件的回调函数将被执行。这是一种常见的设计模式，用于实现事件监听和回调机制。
# 这段代码定义了一个名为 run_callbacks 的方法，它用于触发与指定事件相关联的所有回调函数。这个方法是类的一个成员方法，通常用在支持事件驱动编程的类中。
# 方法签名。
# 1.self ：类的实例。
# 2.event ：事件的名称，这是一个字符串参数，表示将要触发的事件。
def run_callbacks(self, event: str):
# 运行与指定事件相关的所有回调。
"""Runs all callbacks associated with a specified event."""
# self.callbacks 是一个字典，用于存储与特定事件相关联的回调函数列表。
# self.callbacks.get(event, []) 尝试从字典中获取与事件 event 相关联的回调函数列表。如果事件不存在，则返回一个空列表。
# 遍历回调函数列表。
for callback in self.callbacks.get(event, []):
# 调用每个回调函数，并将类的实例 self 作为参数传递给回调函数。
callback(self)
# 这个方法允许类实例在特定事件发生时执行所有注册到该事件的回调函数。这是一种常见的设计模式，用于实现事件监听和回调机制。
# 这段代码定义了一个名为 get_dataloader 的方法，它是一个占位符或抽象方法，用于指示子类应该实现这个方法来获取数据加载器（data loader）。这个方法通常用于机器学习和深度学习中，以便从给定的数据集路径和批处理大小创建一个数据加载器。
# 方法签名。
# 1.self ：类的实例。
# 2.dataset_path ：数据集的路径，这是一个字符串参数，表示数据集文件或目录的位置。
# 3.batch_size ：批处理大小，这是一个整数参数，表示每个批次中的样本数量。
def get_dataloader(self, dataset_path, batch_size):
# 从数据集路径和批量大小获取数据加载器。
"""Get data loader from dataset path and batch size."""
# 这行代码引发了一个 NotImplementedError 异常，表明这个方法在当前类中没有实现，需要在子类中实现。
raise NotImplementedError("get_dataloader function not implemented for this validator") # 该验证器未实现 get_dataloader 函数。
# 这个方法的目的是提供一个接口，让子类可以根据具体的数据集和需求实现数据加载器的创建。这是一种常见的设计模式，用于在基类中定义接口，而在子类中实现具体的功能。
# 这段代码定义了一个名为 build_dataset 的方法，它是一个在验证器（validator）类中使用的占位符或抽象方法，用于指示子类应该实现这个方法来构建数据集。这个方法的目的是从一个图像路径（ img_path ）创建或加载一个数据集。
# 方法签名。
# 1.self ：类的实例。
# 2.img_path ：图像路径，这是一个字符串参数，表示图像文件或包含图像文件的目录的位置。
def build_dataset(self, img_path):
# 建立数据集。
"""Build dataset."""
# 这行代码引发了一个 NotImplementedError 异常，表明这个方法在当前类中没有实现，需要在子类中实现。
raise NotImplementedError("build_dataset function not implemented in validator") # 验证器中未实现 build_dataset 函数。
# 这个方法的目的是提供一个接口，让子类可以根据具体的数据集格式和需求实现数据集的构建。这是一种常见的设计模式，用于在基类中定义接口，而在子类中实现具体的功能。
# 这段代码定义了一个名为 preprocess 的方法，它是一个简单的占位符或默认实现，用于对输入批次（batch）进行预处理。在实际的应用中，这个方法通常会被重写以包含具体的预处理步骤。
# 方法签名。
# 1.self ：类的实例。
# 2.batch ：输入批次，这通常是一个包含多个样本的数据集合，例如在深度学习中一个批次的图像或特征。
def preprocess(self, batch):
# 预处理输入批次。
"""Preprocesses an input batch."""
# 这行代码直接返回传入的批次，不做任何修改。这是一个默认实现，表明在没有特定的预处理需求时，输入数据将直接被使用。
return batch
# 这个方法提供了一个预处理输入数据的接口，可以在子类中根据需要实现具体的预处理逻辑。预处理步骤可能包括数据标准化、归一化、数据增强、调整数据形状等。
# 这段代码定义了一个名为 postprocess 的方法，它是一个简单的占位符或默认实现，用于对模型的预测结果（ preds ）进行后处理。在实际的应用中，这个方法通常会被重写以包含具体的后处理步骤。
# 方法签名。
# 1.self ：类的实例。
# 2.preds ：模型的预测结果，这通常是一个包含多个预测输出的数据集合。
def postprocess(self, preds):
# 预处理预测。
"""Preprocesses the predictions."""
# 这行代码直接返回传入的预测结果，不做任何修改。这是一个默认实现，表明在没有特定的后处理需求时，预测结果将直接被使用。
return preds
# 这个方法提供了一个后处理模型预测结果的接口，可以在子类中根据需要实现具体的后处理逻辑。后处理步骤可能包括将预测概率转换为类别标签、应用阈值、执行非极大值抑制（Non-Maximum Suppression, NMS）等。
# 这段代码定义了一个名为 init_metrics 的方法，它是一个空的方法体，用于初始化用于评估 YOLO（You Only Look Once）模型性能的度量指标。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的初始化逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.model ：模型，这是一个参数，表示要评估的 YOLO 模型。
def init_metrics(self, model):
# 初始化 YOLO 模型的性能指标。
"""Initialize performance metrics for the YOLO model."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的度量指标和模型需求实现。
pass
# 这个方法的目的是提供一个接口，让子类可以初始化用于评估 YOLO 模型性能的度量指标。这些度量指标可能包括精确度、召回率、平均精度（AP）、mAP（mean Average Precision）等。
# 这段代码定义了一个名为 update_metrics 的方法，它是一个空的方法体，用于根据模型的预测结果 ( preds ) 和对应的批次数据 ( batch ) 更新性能度量指标。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的更新逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.preds ：模型的预测结果，这通常是一个包含多个预测输出的数据集合。
# 3.batch ：对应的批次数据，这通常包含输入模型的实际数据和可能的标签或真实值。
def update_metrics(self, preds, batch):
# 根据预测和批次更新指标。
"""Updates metrics based on predictions and batch."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的度量指标和模型需求实现。
pass
# 这个方法的目的是提供一个接口，让子类可以更新用于评估模型性能的度量指标。这些度量指标可能包括精确度、召回率、平均精度（AP）、mAP（mean Average Precision）等，它们通常在模型预测后根据预测结果和真实标签计算得出。
# 这段代码定义了一个名为 finalize_metrics 的方法，它是一个空的方法体，用于完成度量指标的最终计算并返回它们。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的最终计算和返回逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.*args ：任意数量的位置参数，允许方法接受任意额外的位置参数。
# 3.**kwargs ：任意数量的关键字参数，允许方法接受任意额外的关键字参数。
def finalize_metrics(self, *args, **kwargs):
# 完成并返回所有指标。
"""Finalizes and returns all metrics."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的度量指标和模型需求实现。
pass
# 这个方法的目的是提供一个接口，让子类可以完成所有度量指标的最终计算，这可能包括平均值、总和、百分比或其他统计计算，并返回这些度量指标的最终结果。
# 这段代码定义了一个名为 get_stats 的方法，它是一个简单的实现，用于返回模型性能的统计信息。在当前的实现中，这个方法返回一个空字典，表示没有统计信息被收集或计算。
# 方法签名。
# 1.self ：类的实例。
def get_stats(self):
# 返回有关模型性能的统计数据。
"""Returns statistics about the model's performance."""
# 这行代码返回一个空字典，表示当前没有性能统计信息。
return {}
# 这个方法的目的是提供一个接口，用于收集和返回模型性能的统计信息。在实际的应用中，这个方法通常会在子类中被重写，以包含具体的统计计算和信息收集。
# 这段代码定义了一个名为 check_stats 的方法，它是一个空的方法体，用于检查模型性能的统计信息。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的检查逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.stats ：一个字典或对象，包含模型性能的统计信息。
def check_stats(self, stats):
# 检查统计数据。
"""Checks statistics."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的统计信息和需求实现。
pass
# 这个方法的目的是提供一个接口，用于验证和检查模型性能的统计信息是否合理、是否在预期的范围内，或者是否满足某些条件。这可能包括检查精确度、召回率、损失值等是否在合理的范围内，或者是否达到了预定的性能目标。
# 这段代码定义了一个名为 print_results 的方法，它是一个空的方法体，用于打印模型预测的结果。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的打印逻辑。
# 方法签名。
# 1.self ：类的实例。
def print_results(self):
# 打印模型预测的结果。
"""Prints the results of the model's predictions."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的预测结果和需求实现。
pass
# 这个方法的目的是提供一个接口，用于在控制台或其他输出设备上显示模型预测的结果。这可以包括预测的类别、置信度、损失值、准确率等统计信息。
# 这段代码定义了一个名为 get_desc 的方法，它是一个空的方法体，用于获取 YOLO（You Only Look Once）模型的描述信息。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的描述信息获取逻辑。
# 方法签名。
# 1.self ：类的实例。
def get_desc(self):
# 获取 YOLO 模型的描述。
"""Get description of the YOLO model."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的模型和需求实现。
pass
# 这个方法的目的是提供一个接口，用于获取关于 YOLO 模型的描述信息，这些信息可能包括模型的架构、性能指标、版本号、训练参数等。
# 这段代码定义了一个名为 metric_keys 的属性装饰器（使用 @property 装饰器），它用于返回 YOLO 模型在训练或验证过程中使用的度量指标的键（keys）。在这个例子中， metric_keys 返回一个空列表，表示没有度量指标的键被定义或使用。
# 方法签名和装饰器。
# @property ：这是一个装饰器，用于将一个方法转换为属性。这意味着你可以像访问属性一样访问这个方法，而不是作为方法调用（即不需要加括号）。
@property
def metric_keys(self):
# 返回 YOLO 训练/验证中使用的度量键。
"""Returns the metric keys used in YOLO training/validation."""
# 这行代码返回一个空列表，表示当前没有定义任何度量指标的键。
return []
# metric_keys 属性通常用于提供关于哪些度量指标正在被跟踪的元数据。这些键可以用于访问和记录特定的性能指标，例如损失值、精确度、召回率等。
# 这段代码定义了一个名为 on_plot 的方法，它用于在类中注册图表数据，这些数据可以在回调函数中使用。
# 方法签名。
# 1.self ：类的实例。
# 2.name ：图表的名称或路径，这是一个字符串参数。
# 3.data ：图表的数据，这是一个可选参数，默认为 None 。
def on_plot(self, name, data=None):
# 注册图表（例如在回调中使用）。
"""Registers plots (e.g. to be consumed in callbacks)."""
# Path(name) ：将字符串 name 转换为 Path 对象，这可能是为了确保路径的一致性和正确性。
# self.plots ：这是一个字典，用于存储图表数据。
# 将图表数据和时间戳存储在 self.plots 字典中。每个图表都有一个唯一的键（由 Path(name) 提供），并且与一个包含数据和时间戳的字典相关联。
self.plots[Path(name)] = {"data": data, "timestamp": time.time()}
# 这个方法的目的是提供一个接口，用于在类中记录图表数据，这些数据可以被其他方法或回调函数访问和使用。这在可视化训练过程或性能指标时非常有用。
# TODO: may need to put these following functions into callback TODO：可能需要将以下函数放入回调中。
# 这段代码定义了一个名为 plot_val_samples 的方法，它是一个空的方法体，用于在训练过程中绘制验证样本。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的绘图逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.batch ：一个批次的数据，这通常包含一批图像和对应的标签或真实值。
# 3.ni ：批次索引或迭代次数，这是一个整数参数，表示当前批次在训练过程中的位置。
def plot_val_samples(self, batch, ni):
# 在训练期间绘制验证样本。
"""Plots validation samples during training."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的绘图需求和工具实现。
pass
# 这个方法的目的是提供一个接口，用于在训练过程中可视化验证样本，这有助于监控模型的性能和行为。绘制的验证样本可以包括图像、预测结果、真实标签等。
# 这段代码定义了一个名为 plot_predictions 的方法，它是一个空的方法体，用于在训练或验证过程中绘制 YOLO 模型对批次图像的预测结果。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的绘图逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.batch ：一个批次的图像数据，这通常包含一批输入模型的图像。
# 3.preds ：模型对这批图像的预测结果，可能包含边界框、置信度和类别等信息。
# 4.ni ：批次索引或迭代次数，这是一个整数参数，表示当前批次在训练或验证过程中的位置。
def plot_predictions(self, batch, preds, ni):
# 在批量图像上绘制 YOLO 模型预测。
"""Plots YOLO model predictions on batch images."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的绘图需求和工具实现。
pass
# 这个方法的目的是提供一个接口，用于可视化 YOLO 模型的预测结果，这有助于监控模型的性能和行为。绘制的预测结果可以包括边界框、置信度分数、类别标签等。
# 这段代码定义了一个名为 pred_to_json 的方法，它是一个空的方法体，用于将模型的预测结果转换成 JSON 格式。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的转换逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.preds ：模型的预测结果，这通常包含预测的边界框、置信度和类别等信息。
# 3.batch ：对应的批次数据，这通常包含输入模型的图像和可能的真实标签。
def pred_to_json(self, preds, batch):
# 将预测转换为 JSON 格式。
"""Convert predictions to JSON format."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的数据结构和需求实现。
pass
# 这个方法的目的是提供一个接口，用于将预测结果转换成 JSON 格式，这样可以方便地存储、传输或与其他系统进行交互。
# 这段代码定义了一个名为 eval_json 的方法，它是一个空的方法体，用于评估预测结果的统计信息并将它们转换成 JSON 格式。这个方法通常作为一个占位符或抽象方法，在子类中实现具体的评估和转换逻辑。
# 方法签名。
# 1.self ：类的实例。
# 2.stats ：包含预测结果统计信息的字典或对象。
def eval_json(self, stats):
# 评估并返回预测统计数据的 JSON 格式。
"""Evaluate and return JSON format of prediction statistics."""
# 这是一个空操作，表示这个方法在当前类中没有实现具体的功能，需要在子类中根据具体的统计信息和需求实现。
pass
# 这个方法的目的是提供一个接口，用于评估模型的预测性能，并将评估结果转换成 JSON 格式，这样可以方便地存储、传输或与其他系统进行交互。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
