【Yolov5】训练代码train逐句详解_opt.evolve

train.py

import argparse
import logging
import math
import os
import random
import time
from copy import deepcopy
from pathlib import Path
from threading import Thread
 
import numpy as np
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler
import torch.utils.data
import yaml
from torch.cuda import amp
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.tensorboard import SummaryWriter
from tqdm import tqdm
 
import test  # import test.py to get mAP after each epoch
from models.experimental import attempt_load
from models.yolo import Model
from utils.autoanchor import check_anchors
from utils.datasets import create_dataloader
from utils.general import labels_to_class_weights, increment_path, labels_to_image_weights, init_seeds, \
    fitness, strip_optimizer, get_latest_run, check_dataset, check_file, check_git_status, check_img_size, \
    check_requirements, print_mutation, set_logging, one_cycle, colorstr
from utils.google_utils import attempt_download
from utils.loss import ComputeLoss
from utils.plots import plot_images, plot_labels, plot_results, plot_evolution, plot_lr_scheduler
from utils.torch_utils import ModelEMA, select_device, intersect_dicts, torch_distributed_zero_first, is_parallel
from utils.wandb_logging.wandb_utils import WandbLogger, check_wandb_resume
 
logger = logging.getLogger(__name__)
 
 
def train(hyp, opt, device, tb_writer=None):
    logger.info(colorstr('hyperparameters: ') + ', '.join(f'{k}={v}' for k, v in hyp.items()))
    save_dir, epochs, batch_size, total_batch_size, weights, rank = \
        Path(opt.save_dir), opt.epochs, opt.batch_size, opt.total_batch_size, opt.weights, opt.global_rank
########################################################################################################################
    # Directories 设置目录和文件路径，用于保存训练过程中产生的权重文件和结果文件
    #
    # 'wair'是一个路径变量，表示保存权重文件的根目录
    # 其中'save_dir'是一个路径变量，表示保存训练结果的根目录
    # 'wair'变量将在后续保存权重文件的使用
    wdir = save_dir / 'weights'
    # 这一行代码用于创建'wair'指定的目录。'mkdir()'方法会在文件系统中创建目录
    # 'parents=True'表示如果父目录不存在也会自动创建，'exist_ok=True'表示如果目录已存在，则不会抛出异常
    wdir.mkdir(parents=True, exist_ok=True)  # make dir
    # 'last'和'best'是保存最后训练结果和最好训练结果的权重文件的路径变量。
    # 'last'表示最后训练结果的权重文件路径，'best'表示最好训练结果的权重文件路径。
    last = wdir / 'last.pt'
    best = wdir / 'best.pt'
    # 'results_file'是保存训练结果的文件路径变量，这里命名为'results.txt'，用于记录训练过程中的指标和性能结果。
    # 在训练结束后，训练结果会写入到这个文件中。
    results_file = save_dir / 'results.txt'
########################################################################################################################
    # Save run settings 这段代码用于将训练过程中的配置信息保存到 YAML 文件中，以备后续查阅和复现实验
    #
    # 将超参数'hyp'(定义了训练过程中的各种超参数)保存到'hyp.yaml'文件中
    # 'hyp'是一个字典类型变量，它包含了训练过程在的各种超参数，例如学习率、权重衰减、数据增强等
    # 'yaml.dump()'函数用于将字典内容以YAML格式写入到'hyp.yaml'文件中
    with open(save_dir / 'hyp.yaml', 'w') as f:
        yaml.dump(hyp, f, sort_keys=False)
    # 这部分代码将命令行传递的参数'opt'（包含训练配置的命令行参数）保存到'opt.yaml'文件中
    # 'opt'是一个'Namespace'对象，它包含了用户在命令行中指定的各种训练配置参数，例如数据集路径、模型架构、批次大小等
    # 'vars(opt)'函数将'Namespace'对象转换为字典，然后使用'yaml.dump()'将其以 YAML 格式写入到'opt.yaml'文件中
    with open(save_dir / 'opt.yaml', 'w') as f:
        yaml.dump(vars(opt), f, sort_keys=False)
########################################################################################################################
    # Configure  进行一些配置和初始化操作，为后续的训练过程做准备
    #
    # 这行代码用于设置是否创建训练过程中的可视化图表
    # 'opt.evolve'是一个命令行参数，如果设置了'--evolve'，则'opt.evolve'为'True'，表示启用进化算法
    # 如果没有设置'--evolve'，则'opt.evolve'为'False'，这时'plots'将为'True'，表示创建训练过程中的图表。
    plots = not opt.evolve  # create plots
    # 这行代码用于检查是否使用GPU进行训练
    cuda = device.type != 'cpu'
    # 这行代码用于初始化随机种子
    # 'init_seeds()'是一个自定义的函数，它将随机种子设置为一个特定的值，以确保每次运行代码时产生的随机结果是可复现的。
    # 'rank'表示当前进程的排名（通常用于多GPU或分布式训练时），这里加上了2是为了使每个进程的随机种子不同，避免冲突。
    init_seeds(2 + rank)
    # 这行代码用于加载数据集配置信息
    # 'opt.data'是命令行参数，表示数据集的配置文件路径
    # 'yaml.load()'函数用于从配置文件中加载数据集的配置信息，并存储在'data_dict'变量中
    # 数据集配置文件通常使用YAML格式来定义数据集的相关信息，例如数据路径、类别标签等
    with open(opt.data) as f:
        data_dict = yaml.load(f, Loader=yaml.SafeLoader)  # data dict
    # 这行代码用于检查数据集是否为coco格式
    # 判断结尾是否以'coco.yaml'结尾，不是则输出False，是则为True
    is_coco = opt.data.endswith('coco.yaml')
########################################################################################################################
    # Logging- Doing this before checking the dataset. Might update data_dict
    # 这段代码用于设置日志记录器和加载之前保存的训练信息，同时也更新了数据集的相关配置信息
    #
    # 创建一个日志记录器字典
    loggers = {'wandb': None}  # loggers dict
    # 检查当前进程的排名'rank'是否为-1或0，'rank'表示当前进程的排名，-1表示单GPU训练，0表示主进程
    if rank in [-1, 0]:
        # 这行代码将之前加载的超参数'hyp'（定义了训练过程中的各种超参数）赋值给训练配置参数'opt.hyp'。
        # 这样，训练配置中就包含了超参数信息，方便后续的日志记录
        opt.hyp = hyp  # add hyperparameters
        # 用于从之前保存的权重文件中加载 Wandb 的运行标识符（run_id）。'weights'是之前指定的权重文件路径
        # 如果'weights'是以'.pt'结尾并且是一个存在的文件，就通过'torch.load()'加载该权重文件，并从中获取'wandb_id'
        # 如果找不到'wandb_id'或者'weights'不是以'.pt'结尾或者不是一个存在的文件，'run_id'将被设置为'None'
        run_id = torch.load(weights).get('wandb_id') if weights.endswith('.pt') and os.path.isfile(weights) else None
        # 这行代码将WandbLoger对象中的'data_dict'属性赋值给数据集配置信息'data_dict'
        wandb_logger = WandbLogger(opt, Path(opt.save_dir).stem, run_id, data_dict)
        # 这行代码将WandLogger对象中的'wandb'属性存储到'loggers'字典中，方便后续使用
        loggers['wandb'] = wandb_logger.wandb
        # 将'data_dict'赋值给数据集的配置信息
        data_dict = wandb_logger.data_dict
        # 检查WandbLogger是否成功创建了对象
        if wandb_logger.wandb:
            weights, epochs, hyp = opt.weights, opt.epochs, opt.hyp  # WandbLogger might update weights, epochs if resuming
########################################################################################################################
    # 这段代码用于确定训练数据集中的类别数量以及类别名称，并进行相关的检查
    # 这行代码用于确定数据集中的类别数量'nc'
    nc = 1 if opt.single_cls else int(data_dict['nc'])  # number of classes
    # 确定数据集中的类别名称
    names = ['item'] if opt.single_cls and len(data_dict['names']) != 1 else data_dict['names']  # class names
    # 检查类别名称数量是否与类别数量'nc'相等
    assert len(names) == nc, '%g names found for nc=%g dataset in %s' % (len(names), nc, opt.data)  # check
########################################################################################################################
    # Model 用于创建和加载模型，并根据是否有预训练权重选择加载已有的模型权重或者创建一个新的模型
    #
    # 用于检查训练权重是否为以'pt'结尾的文件
    pretrained = weights.endswith('.pt')
    # 根据是否有预训练权重文件来选择执行不同的代码
    if pretrained:
        # 用于在分布式训练中，保证只有rank为0的进程执行此块中的代码
        with torch_distributed_zero_first(rank):
            # 用于尝试下载预训练权重文件
            attempt_download(weights)  # download if not found locally
        # 加载预训练权重文件
        ckpt = torch.load(weights, map_location=device)  # load checkpoint
        # 创建模型
        # 'opt.cfg'是训练配置的命令行参数，表示模型的配置文件路径。如果'opt.cfg'为空，则使用预训练模型中的配置文件 ckpt['model'].yaml
        # 'ch=3'表示输入图像的通道数为3（RGB图像）,'nc=nc'表示输出类别数量（之前已经确定了），'anchors=hyp.get('anchors)' 表示使用之前加载的超参数中的锚框信息
        model = Model(opt.cfg or ckpt['model'].yaml, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
        # 确定要排除的模型参数键名列表
        exclude = ['anchor'] if (opt.cfg or hyp.get('anchors')) and not opt.resume else []  # exclude keys
        # 将预训练模型的参数转换为FP32数据类型，将其存储在'state_dict'变量中
        state_dict = ckpt['model'].float().state_dict()  # to FP32
        # 获取预训练模型参数和当前模型的参数的交集，并将结果存储在'state_dict'变量中。排除了'anchor'键名的参数
        state_dict = intersect_dicts(state_dict, model.state_dict(), exclude=exclude)  # intersect
        # 将'state_dict'中的参数加载到当前模型中。'strict=False'表示允许加载不匹配的参数，这是因为预训练模型和当前模型可能具有不同的层结构
        model.load_state_dict(state_dict, strict=False)  # load
        # 输出日志信息，报告从预训练模型成功加载了多少个参数到当前模型中
        logger.info('Transferred %g/%g items from %s' % (len(state_dict), len(model.state_dict()), weights))  # report
    else:
        model = Model(opt.cfg, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
        # 这行代码用于在分布式训练中，保证只有 rank 为 0 的进程执行此块中的代码
    with torch_distributed_zero_first(rank):
        # 检查数据集是否有效，确保数据集配置信息中的路径等设置正确
        check_dataset(data_dict)  # check
    # 从数据集配置信息中获取训练集路径，并将其存储在'train_path'变量中
    train_path = data_dict['train']
    # 从数据集配置信息中获取验证集路径，并将其存储在'test_path'变量中
    test_path = data_dict['val']
########################################################################################################################
    # Freeze 这段代码用于冻结模型的某些层，即设置这些层的参数不参与训练，以保持预训练权重的固定
    #
    # 定义空列表，存储需要冻结的参数名
    freeze = []  # parameter names to freeze (full or partial)
    # 遍历模型中所有参数和参数名称
    for k, v in model.named_parameters():
        # 允许参数参与训练，确保所有参数都参与训练，而不受后续冻结的影响
        v.requires_grad = True  # train all layers
        # 检查当前参数名称'k'是否包含在需要冻结的参数名列表'freeze'之中
        if any(x in k for x in freeze):
            # 这行代码输出日志信息，表示当前参数名称'k'被冻结
            print('freezing %s' % k)
            # 将当前参数'v'的'requires_grad'属性设置为False，表示冻结参数，不参与训练
            v.requires_grad = False
########################################################################################################################
    # Optimizer 这段代码的作用是设置优化器
    #
    nbs = 64  # nominal batch size
    # 'nbs'是标准批次大小，'total_batch_size'是实际使用的总批次大小
    # 根据批次大小的比例来确定累积的步数，以便在计算梯度时进行优化
    accumulate = max(round(nbs / total_batch_size), 1)  # accumulate loss before optimizing
    hyp['weight_decay'] *= total_batch_size * accumulate / nbs  # scale weight_decay
    logger.info(f"Scaled weight_decay = {hyp['weight_decay']}")
########################################################################################################################
    # 创建优化器参数组：根据模型的不同参数，将其分为三个不同的优化器参数组
    # 分别用于处理偏置项(biases)，BatchNorm2d层的权重(不衰减)和其他层的权重(进行衰减)
    pg0, pg1, pg2 = [], [], []  # optimizer parameter groups
    for k, v in model.named_modules():
        if hasattr(v, 'bias') and isinstance(v.bias, nn.Parameter):
            pg2.append(v.bias)  # biases
        if isinstance(v, nn.BatchNorm2d):
            pg0.append(v.weight)  # no decay
        elif hasattr(v, 'weight') and isinstance(v.weight, nn.Parameter):
            pg1.append(v.weight)  # apply decay
########################################################################################################################
    # 根据命令行参数'opt.adam'的值来选择使用Adam优化器或SGD优化器
    if opt.adam:
        optimizer = optim.Adam(pg0, lr=hyp['lr0'], betas=(hyp['momentum'], 0.999))  # adjust beta1 to momentum
    else:
        optimizer = optim.SGD(pg0, lr=hyp['lr0'], momentum=hyp['momentum'], nesterov=True)
    # 将参数组添加到优化器：将'pg1'的权重参数添加到优化器，这些参数需要进行权重衰减
    # 将'pg2'的参数添加到优化器，这些参数是偏置项，不需要进行权重衰减
    optimizer.add_param_group({'params': pg1, 'weight_decay': hyp['weight_decay']})  # add pg1 with weight_decay
    optimizer.add_param_group({'params': pg2})  # add pg2 (biases)
    # 输出优化器参数组信息：使用'logger.info'将优化器参数组的信息输出到日志中
    logger.info('Optimizer groups: %g .bias, %g conv.weight, %g other' % (len(pg2), len(pg1), len(pg0)))
    # 清理不再需要的变量
    del pg0, pg1, pg2
########################################################################################################################
    # Scheduler https://arxiv.org/pdf/1812.01187.pdf
    # 设置学习率调度器(Scheduler)的部分，用于动态调整优化器的学习率
    # https://pytorch.org/docs/stable/_modules/torch/optim/lr_scheduler.html#OneCycleLR
    # 根据命令行参数'opt.linear_lr'的值选择学习率调度器函数
    # True:线性学习率调度器函数  使用线性插值来计算每个epoch的学习率，初始学习率(lr)为'1.0'，在最后一个epoch时降低到'hyp['lrf']'
    # False:余弦退火学习率调度器函数  使用余弦退火策略来调整学习率，学习率初始值'1.0'逐渐降低到'hyp['lrf']'，然后再逐渐增加回初始值
    if opt.linear_lr:
        lf = lambda x: (1 - x / (epochs - 1)) * (1.0 - hyp['lrf']) + hyp['lrf']  # linear
    else:
        lf = one_cycle(1, hyp['lrf'], epochs)  # cosine 1->hyp['lrf']
    # 创建学习率调度器。动态调整优化器的学习率
    scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)
    # 绘制学习率调度器曲线(可选)，可以可视化学习率的变化趋势
    plot_lr_scheduler(optimizer, scheduler, epochs)
 
    # EMA 创建一个指数移动平均模型，用来稳定模型训练和高泛化性能
    # 在训练过程中，EMA模型会周期性地更新其权重，计算方式是通过指数衰减来更新原始模型的权重。这样做的目的是减少模型在训练过程中的波动性
    # 从而提高模型的稳定性和泛化性能。在训练结束后，使用EMA模型的权重来进行推断（inference）可以获得更稳定和泛化性能更好的结果
    ema = ModelEMA(model) if rank in [-1, 0] else None
########################################################################################################################
    # Resume 处理训练过程中的模型断点续训(Resume)操作，使可以在训练过程中中断，并在之后恢复训练
    #
    # 记录训练的起始epoch和最佳模型性能指标(比如验证集上的精度或损失)
    start_epoch, best_fitness = 0, 0.0
    # 如果之前已经从预训练模型（pretrained）加载了断点（checkpoint），则检查该断点中是否包含了优化器（optimizer）的状态和最佳模型性能指标（best_fitness）
    if pretrained:
        # Optimizer 如果优化器的状态存在，则将之前保存的优化器状态加载回来，以便继续训练
        if ckpt['optimizer'] is not None:
            optimizer.load_state_dict(ckpt['optimizer'])
            best_fitness = ckpt['best_fitness']
 
        # EMA 加载之前保存的EMA模型状态
        if ema and ckpt.get('ema'):
            ema.ema.load_state_dict(ckpt['ema'].float().state_dict())
            ema.updates = ckpt['updates']
 
        # Results 处理训练过程中的结果保存
        if ckpt.get('training_results') is not None:
            results_file.write_text(ckpt['training_results'])  # write results.txt
 
        # Epochs 处理训练的epoch(训练轮数)设置和恢复(resume)训练
        start_epoch = ckpt['epoch'] + 1
        if opt.resume:
            assert start_epoch > 0, '%s training to %g epochs is finished, nothing to resume.' % (weights, epochs)
        if epochs < start_epoch:
            logger.info('%s has been trained for %g epochs. Fine-tuning for %g additional epochs.' %
                        (weights, ckpt['epoch'], epochs))
            epochs += ckpt['epoch']  # finetune additional epochs
 
        del ckpt, state_dict
########################################################################################################################
    # Image sizes 图像大小相关的设置
    #
    # 获取模型中所有层的步幅(stride)的最大值，然后取该最大值和32的较大值作为网格大小'gs'
    gs = max(int(model.stride.max()), 32)  # grid size (max stride)
    # 获取模型中最后一个检测层的数量(detection layers)，并将该数量用于后续的'hyb['obj']'缩放操作
    nl = model.model[-1].nl  # number of detection layers (used for scaling hyp['obj'])
    # 将获取的输入图像大小分别赋值给'imagz'和'imagz_test'，用于训练和测试阶段使用不同的输入图像大小
    imgsz, imgsz_test = [check_img_size(x, gs) for x in opt.img_size]  # verify imgsz are gs-multiples
########################################################################################################################
    # DP mode 深度并行(Data Parallel)模式的设置
    #
    # 检查当前是否满足使用深度并行模式的条件
    if cuda and rank == -1 and torch.cuda.device_count() > 1:
        # 将'model'进行封装，以实现深度并行模式。加速训练过程(特别是在有多个GPU的情况下)
        model = torch.nn.DataParallel(model)
 
    # SyncBatchNorm 进行同步批归一化的设置
    #
    # 检查是否满足使用同步批归一化的条件
    if opt.sync_bn and cuda and rank != -1:
        # 将模型中的批归一化层转换为同步批归一化层。同步批归一化是为了解决在分布式训练中批归一化带来的同步问题
        # 在分布式训练中，不同进程的批归一化层的均值和方差可能会有偏差
        # 同步批归一化通过在所有进程间进行均值和方差的全局同步，从而保证每个进程使用的均值和方差是一致的，解决了同步问题
        model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device)
        logger.info('Using SyncBatchNorm()')
########################################################################################################################
    # Trainloader 创建用于训练的数据加载器
    #
    # 创建数据加载器，传递给函数的参数包括：
    # train_path：训练数据集的路径 /  imgsz：图像的尺寸，用于调整图像的大小  /  batch_size：每个批次的样本数
    # gs：网络的最大步幅（grid size） /   opt：命令行选项的配置  /  hyp：超参数的配置  /  augment：是否进行数据增强
    # cache：是否缓存图像数据  /  rect：是否使用矩形（rectangle）数据增强  /  rank：当前进程的排名，用于分布式训练
    # world_size：总的进程数，用于分布式训练  /  workers：数据加载器使用的工作进程数  /  image_weights：图像权重，用于样本不均衡问题
    # quad：是否使用四分之一数据增强  /  prefix：输出的前缀标识，用于日志记录
    dataloader, dataset = create_dataloader(train_path, imgsz, batch_size, gs, opt,
                                            hyp=hyp, augment=True, cache=opt.cache_images, rect=opt.rect, rank=rank,
                                            world_size=opt.world_size, workers=opt.workers,
                                            image_weights=opt.image_weights, quad=opt.quad, prefix=colorstr('train: '))
    # dataloader: PyTorch的数据加载器，用于加载训练数据并生成批次
    # dataset: 数据集对象，其中包括加载的图像数据以及对应的标签
    # 计算标签中最大的类别编号
    mlc = np.concatenate(dataset.labels, 0)[:, 0].max()  # max label class
    # 获取数据加载器的批次数量，保存在'nb'中
    nb = len(dataloader)  # number of batches
    # 使用'assert'语句进行断言，确保数据集的最大类别编号'mlc'小于总的类别数'nc'
    assert mlc < nc, 'Label class %g exceeds nc=%g in %s. Possible class labels are 0-%g' % (mlc, nc, opt.data, nc - 1)
########################################################################################################################
    # Process 0 处理进程0的逻辑
    if rank in [-1, 0]:
        # 用于验证(测试)的数据加载器
        testloader = create_dataloader(test_path, imgsz_test, batch_size * 2, gs, opt,  # testloader
                                       hyp=hyp, cache=opt.cache_images and not opt.notest, rect=True, rank=-1,
                                       world_size=opt.world_size, workers=opt.workers,
                                       pad=0.5, prefix=colorstr('val: '))[0]
        # 如果'opt.resume'为'False'，即不从断点恢复训练，则执行下面的操作
        if not opt.resume:
            # 将所有样本的标签连接成一个数组，并保存在'labels'中
            labels = np.concatenate(dataset.labels, 0)
            # 从labels中提取出所有样本的类别编号(classes),保存在'c'中
            c = torch.tensor(labels[:, 0])  # classes
            # cf = torch.bincount(c.long(), minlength=nc) + 1.  # frequency
            # model._initialize_biases(cf.to(device))
            # 如果'plots'为'True',则绘制类别标签的分布图，并保存在'save_dir'指定的路径中
            # 'plot_labels()'函数用于绘制标签的分布图
            if plots:
                plot_labels(labels, names, save_dir, loggers)
                # 如果'tb_writer'存在(即TensorBoard的写入器对象)，则将类别编号直方图添加到TensorBoard中，用于可视化
                if tb_writer:
                    tb_writer.add_histogram('classes', c, 0)
 
            # Anchors
            if not opt.noautoanchor:
                check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz)
            model.half().float()  # pre-reduce anchor precision
########################################################################################################################
    # DDP mode 处理分布式数据并行(DDP)模式的逻辑
    if cuda and rank != -1:
        # 使用'DDP'函数将模型包装成分布式数据并行模型
        # 'DDP'是PyTorch中的分布式训练工具，可以在多个GPU上进行模型的数据并行训练
        model = DDP(model, device_ids=[opt.local_rank], output_device=opt.local_rank,
                    # nn.MultiheadAttention incompatibility with DDP https://github.com/pytorch/pytorch/issues/26698
                    find_unused_parameters=any(isinstance(layer, nn.MultiheadAttention) for layer in model.modules()))
########################################################################################################################
    # Model parameters 对模型的一些参数进行调整和配置
    #
    # 以下三行分别对应着目标框回归损失、类别损失、目标检测损失(IOU损失)的权重
    # 通过乘以一些系数，将这些权重进行了缩放，其中'n1'代表着模型中的目标检测层数(detection layers)
    hyp['box'] *= 3. / nl  # scale to layers
    hyp['cls'] *= nc / 80. * 3. / nl  # scale to classes and layers
    hyp['obj'] *= (imgsz / 640) ** 2 * 3. / nl  # scale to image size and layers
    # 对标签平滑处理的超参数，用于减少模型对训练数据中标签噪声的过度依赖
    hyp['label_smoothing'] = opt.label_smoothing
    # 检测任务中的类别数
    model.nc = nc  # attach number of classes to model
    # 超参数字典
    model.hyp = hyp  # attach hyperparameters to model
    # IOU损失和目标检测损失之间的权重比例，1.0时二者权重相等
    model.gr = 1.0  # iou loss ratio (obj_loss = 1.0 or iou)
    # 通过标签计算得到的类别权重，用于在损失计算中对不同类别的样本进行加权处理
    model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) * nc  # attach class weights
    # 用于在输出结果中显示类别名称
    model.names = names
########################################################################################################################
    # Start training 模型的训练部分，使用一个循环来遍历每个epoch，训练模型
    #
    # 用于记录训练开始的时间，用于后续计算训练总时长
    t0 = time.time()
    # 计算预热(iteration-based)的迭代次数
    # 预热是训练初期使用较小学习率来进行参数的热身，防止模型一开始就产生激烈的更新
    nw = max(round(hyp['warmup_epochs'] * nb), 1000)  # number of warmup iterations, max(3 epochs, 1k iterations)
    # nw = min(nw, (epochs - start_epoch) / 2 * nb)  # limit warmup to < 1/2 of training
    # 用于记录每个类别的平均准确率(mAP)，'nc'是类别总数
    maps = np.zeros(nc)  # mAP per class
    # 一个包含多个零元素的元组，用于记录训练过程中的一些统计结果
    results = (0, 0, 0, 0, 0, 0, 0)  # P, R, mAP@.5, mAP@.5-.95, val_loss(box, obj, cls)
    # 让学习率调度器从正确的epoch开始调整学习率
    scheduler.last_epoch = start_epoch - 1  # do not move
    # 用于配置自动混合精度训练
    # AMP是一种加速训练的技术，通过在训练过程中使用更低精度的数值减少计算量
    scaler = amp.GradScaler(enabled=cuda)
    # 用于初始化计算损失的类
    compute_loss = ComputeLoss(model)  # init loss class
    # 将模型设置为训练模式，这样在后续的训练中会使用dropout等训练特定的操作，接下来的代码会在每个epoch中进行模型的训练
    logger.info(f'Image sizes {imgsz} train, {imgsz_test} test\n'
                f'Using {dataloader.num_workers} dataloader workers\n'
                f'Logging results to {save_dir}\n'
                f'Starting training for {epochs} epochs...')
    for epoch in range(start_epoch, epochs):  # epoch ------------------------------------------------------------------
 
        # 将模型设置为训练模式，这样在后续的训练中会使用dropout等训练特定的操作
        model.train()
 
        # Update image weights (optional)  更新图像权重，这是一个可选的操作，用于调整样本的权重
        # 在训练中更加关注一些难以分类的样本
        #
        # 在进程0或者GPU情况下，计算每个类别的权重cw，这些权重将根据每个类别的mAP(平均准确率)进行调整，mAP越低，该类别权重越高
        if opt.image_weights:
            # Generate indices
            if rank in [-1, 0]:
                cw = model.class_weights.cpu().numpy() * (1 - maps) ** 2 / nc  # class weights
                # 函数生成每个样本的权重iw
                # 该函数会将每个样本的权重与其所属的类别相关联，使用之前计算得到的cw来调整每个类别的样本权重
                iw = labels_to_image_weights(dataset.labels, nc=nc, class_weights=cw)  # image weights
                # 生成一个根据iw进行加权的样本索引列表
                # 这里是使用权重iw从数据集中随机选择样本，选择的样本数量为数据集中样本总数dataset.n
                dataset.indices = random.choices(range(dataset.n), weights=iw, k=dataset.n)  # rand weighted idx
            # Broadcast if DDP
            # 如果是分布式训练，将根据情况广播生成的样本索引，确保所有进程都有相同的样本索引
            # 将数据集dataset的indices属性更新为新生成的样本索引，后续训练将根据这些更新的权重进行样本采样
            if rank != -1:
                indices = (torch.tensor(dataset.indices) if rank == 0 else torch.zeros(dataset.n)).int()
                dist.broadcast(indices, 0)
                if rank != 0:
                    dataset.indices = indices.cpu().numpy()
 
        # Update mosaic border
        # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)
        # dataset.mosaic_border = [b - imgsz, -b]  # height, width borders
 
        # 在这段代码中，首先定义了一个tensor'mloss'，用于记录每个batch的平均损失
        # 然后根据rank值(进程编号)，相应地设置dataloader的采样器，确保在分布式训练中每个进程的数据都是随机的
        mloss = torch.zeros(4, device=device)  # mean losses
        if rank != -1:
            dataloader.sampler.set_epoch(epoch)
        # 使用enumerate函数便利dataloader中的每个batch
        # 在遍历过程中，将图像(imgs)和目标(targets)移到指定的设备(device)，并将像素值从unit8转换为float32，并进行归一化(除以255)
        pbar = enumerate(dataloader)
        logger.info(('\n' + '%10s' * 8) % ('Epoch', 'gpu_mem', 'box', 'obj', 'cls', 'total', 'labels', 'img_size'))
        # 用于显示训练进度的进度条，如果rank为0或单GPU训练，则创建一个tqdm进度条，并设置总的迭代次数为nb(一个epoch内的batch数量)
        # 在进度条中，会显示当前的迭代次数和一些损失信息，如box损失、obj损失、cls损失等
        if rank in [-1, 0]:
            pbar = tqdm(pbar, total=nb)  # progress bar
        optimizer.zero_grad()
        # 对于每个batch，进行相应的训练操作
        for i, (imgs, targets, paths, _) in pbar:  # batch -------------------------------------------------------------
            ni = i + nb * epoch  # number integrated batches (since train start)
            imgs = imgs.to(device, non_blocking=True).float() / 255.0  # uint8 to float32, 0-255 to 0.0-1.0
 
            # Warmup
            # 在warmup阶段，学习率和动量会逐渐从较小的值递增到初始值
            # 下面采用了线性插值的方法，根据当前迭代次数ni的值，计算对应的学习率和动量
            if ni <= nw:
                # 首先定义了一个长度为2的列表xi，其中第一个元素为0，第二个元素为nw（warmup_iterations）。
                # 然后，通过np.interp函数，根据当前迭代次数ni在xi中进行插值，得到学习率和动量的插值结果。
                # 在这个过程中，学习率的插值范围是从warmup_bias_lr（bias项的学习率）到初始学习率（x['initial_lr'] * lf(epoch)），
                # 动量的插值范围是从warmup_momentum到初始动量hyp['momentum']。
                xi = [0, nw]  # x interp
                # model.gr = np.interp(ni, xi, [0.0, 1.0])  # iou loss ratio (obj_loss = 1.0 or iou)
                accumulate = max(1, np.interp(ni, xi, [1, nbs / total_batch_size]).round())
                # 根据插值的结果，将学习率和动量的值分别赋给优化器中的参数组(optimizer.param_groups)
                # 这样的操作是为了在warmup阶段，优化器的学习率和动量会逐渐增加，使得模型在训练初期更加稳定
                # 当warmup阶段结束后，学习率和动量会保持在初始值
                for j, x in enumerate(optimizer.param_groups):
                    # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0
                    x['lr'] = np.interp(ni, xi, [hyp['warmup_bias_lr'] if j == 2 else 0.0, x['initial_lr'] * lf(epoch)])
                    if 'momentum' in x:
                        x['momentum'] = np.interp(ni, xi, [hyp['warmup_momentum'], hyp['momentum']])
 
            # Multi-scale 在训练过程中进行多尺度数据增强(multi-scale data augmentation)的功能
            # 检查是否开启了多尺度数据增强
            if opt.multi_scale:
                # 生成新的图像尺寸sz，尺寸在原始图像尺寸的0.5到1.5倍之间
                # 是grid size(gs)的倍数，以保持对齐
                # 得到一个新的随机尺寸，用于对图像进行缩放
                sz = random.randrange(imgsz * 0.5, imgsz * 1.5 + gs) // gs * gs  # size
                # 计算图形缩放比例因子sf，如果sf不等于1，说明图形需要进行缩放
                # 根据缩放因子sf，计算新的图像尺寸ns，这里采用的是向上取整，使得新尺寸为grid size(gs)的倍数
                sf = sz / max(imgs.shape[2:])  # scale factor
                if sf != 1:
                    ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]]  # new shape (stretched to gs-multiple)
                    # 使用'F.interpolate'对图像进行缩放，将图像的尺寸变为ns
                    # 实现了在训练过程中对图像进行多尺度数据增强，增强了模型对不同大小目标的适应性
                    imgs = F.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
 
            # Forward 实现了模型的前向传播和损失的计算
            # 使用PyTorch的自动混合精度AMP机制来开启混合精度计算
            # 混合精度计算可以通过使用半精度浮点数(float16)来加速模型的计算，从而提高训练速度
            with amp.autocast(enabled=cuda):
                # 将图像数据imgs传入模型，得到预测结果pred
                # 模型的forward方法会对输入图像进行特征提取和目标检测，包含检测框、类别和置信度等信息
                pred = model(imgs)  # forward
                # 使用'compute_loss'函数计算模型的损失值loss和各个损失项loss_items
                # 损失值会根据批次大小(batch_size)进行缩放
                # 在分布式数据并行(DDP)模式下，还会对损失进行梯度平均，以确保不同设备上的梯度更新一致
                loss, loss_items = compute_loss(pred, targets.to(device))  # loss scaled by batch_size
                if rank != -1:
                    loss *= opt.world_size  # gradient averaged between devices in DDP mode
                # 如果使用了opt.quad选项，还会将损失值再乘以4，这是为了调整梯度的缩放，以避免梯度消失或爆炸的问题
                # 最后的loss和loss_items将在后续的反向传播和优化器更新中使用
                if opt.quad:
                    loss *= 4.
 
            # Backward 反向传播
            # 使用之前创建的amp.GradScaler对象scaler对损失值loss进行缩放（scale），然后调用backward()方法执行反向传播
            # 反向传播计算各个参数的梯度，并将梯度存储在各个参数的.grad属性中
            scaler.scale(loss).backward()
 
            # Optimize 优化器更新
            # 当累计足够多的梯度，则调用'scaler.step(optimizer)'来执行优化器的更新步骤
            # 优化器会根据梯度和设定的学习率等参数，更新模型的参数值，使得损失值逐渐减小，从而训练模型
            if ni % accumulate == 0:
                scaler.step(optimizer)  # optimizer.step
                # 更新优化器后，使用'scaler.update()'更新scaler的缩放因子
                # 这个缩放因子是为了调整梯度缩放的比例，使得模型的训练更加稳定
                scaler.update()
                # 对优化器进行梯度清零，以准备处理下一个批次的数据
                optimizer.zero_grad()
                # 如果使用了EMA指数移动平均技术进行模型的平均权重更新，则会在这里调用ema.update(model)来更新模型的EMA权重
                if ema:
                    ema.update(model)
 
            # Print 用于打印训练过程中的相关信息
            # 计算当前训练批次的平均损失值
            if rank in [-1, 0]:
                # 使用如下公式更新mloss
                # 其中，i是当前批次的索引，该公式用于计算平均损失值，将当前损失值加入到之前的平均值中，并更新为新的平均值
                mloss = (mloss * i + loss_items) / (i + 1)  # update mean losses
                # 获取当前GPU的内存使用情况，将内存使用量转为GB，并将其保存在mem变量中
                mem = '%.3gG' % (torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0)  # (GB)
                # 构造要打印的信息字符串s，其中包含了当前的训练轮数、GPU内存使用量、平均损失值以及当前批次的样本数和图像大小
                s = ('%10s' * 2 + '%10.4g' * 6) % ('%g/%g' % (epoch, epochs - 1), mem, *mloss, targets.shape[0], imgs.shape[-1])
                # 将信息字符串s显示在进度条上，实时更新训练过程中的信息
                pbar.set_description(s)
 
                # Plot
                # 检查是否需要绘图，以及当前的批次索引ni是否小于3
                # 满足条件，则创建一个线程来异步执行绘图操作，以避免阻塞主线程的训练过程
                if plots and ni < 3:
                    # 绘图操作会调用'plot_images'函数，将当前的图像、目标框以及文件路径绘制在一张图上，并进行保存
                    f = save_dir / f'train_batch{ni}.jpg'  # filename
                    Thread(target=plot_images, args=(imgs, targets, paths, f), daemon=True).start()
                    # if tb_writer:
                    #     tb_writer.add_image(f, result, dataformats='HWC', global_step=epoch)
                    #     tb_writer.add_graph(torch.jit.trace(model, imgs, strict=False), [])  # add model graph
                # 如果当前批次索引ni等于10，并且'wandb_logger'中有wandb日志记录器，就会将之前保存的图像文件加载到wandb日志中
                elif plots and ni == 10 and wandb_logger.wandb:
                    wandb_logger.log({"Mosaics": [wandb_logger.wandb.Image(str(x), caption=x.name) for x in
                                                  save_dir.glob('train*.jpg') if x.exists()]})
 
            # end batch ------------------------------------------------------------------------------------------------
        # end epoch ----------------------------------------------------------------------------------------------------
########################################################################################################################
        # Scheduler  获取当前优化器optimizer中各个参数组的学习率，并保存在列表中
        lr = [x['lr'] for x in optimizer.param_groups]  # for tensorboard
        # 将优化器的学习率按照预定的学习率调度方式进行更新
        scheduler.step()
########################################################################################################################
        # DDP process 0 or single-GPU
        if rank in [-1, 0]:
            # mAP
            # 更新EMA模型的属性，通过'ema.update_attr()'，将著模型的属性更新到EMA模型中
            ema.update_attr(model, include=['yaml', 'nc', 'hyp', 'gr', 'names', 'stride', 'class_weights'])
            final_epoch = epoch + 1 == epochs
            # 判断是否需要进行测试(计算mAP)
            if not opt.notest or final_epoch:  # Calculate mAP
                wandb_logger.current_epoch = epoch + 1
                # 调用test.test()函数进行测试
                results, maps, times = test.test(data_dict,
                                                 batch_size=batch_size * 2,
                                                 imgsz=imgsz_test,
                                                 model=ema.ema,
                                                 single_cls=opt.single_cls,
                                                 dataloader=testloader,
                                                 save_dir=save_dir,
                                                 verbose=nc < 50 and final_epoch,
                                                 plots=plots and final_epoch,
                                                 wandb_logger=wandb_logger,
                                                 compute_loss=compute_loss,
                                                 is_coco=is_coco)
 
            # Write 将训练过程中计算得到的指标和验证集上的指标写入到文件中，并进行保存操作
            # 打开'results_file'文件，以追加模式('a')写入数据
            with open(results_file, 'a') as f:
                # 使用字符串格式化的方式将训练过程中的一些信息(epoch、内存占用、损失函数值等)和验证集上的指标(P、R、mAP)写入到文件中
                f.write(s + '%10.4g' * 7 % results + '\n')  # append metrics, val_loss
            if len(opt.name) and opt.bucket:
                # 'gsutil cp'命令用于将'results_file'文件复制到指定路径上
                os.system('gsutil cp %s gs://%s/results/results%s.txt' % (results_file, opt.bucket, opt.name))
 
            # Log 训练过程中的损失函数值、验证集上的指标以及学习率等信息记录到日志中
            tags = ['train/box_loss', 'train/obj_loss', 'train/cls_loss',  # train loss
                    'metrics/precision', 'metrics/recall', 'metrics/mAP_0.5', 'metrics/mAP_0.5:0.95',
                    'val/box_loss', 'val/obj_loss', 'val/cls_loss',  # val loss
                    'x/lr0', 'x/lr1', 'x/lr2']  # params
            # 遍历训练过程中的损失函数值、验证集上的指标以及学习率等信息，并添加到日志
            for x, tag in zip(list(mloss[:-1]) + list(results) + lr, tags):
                if tb_writer:
                    tb_writer.add_scalar(tag, x, epoch)  # tensorboard
                if wandb_logger.wandb:
                    wandb_logger.log({tag: x})  # W&B
 
            # Update best mAP 更新最佳的mAP平均指标
            # 将验证集上的指标'results'通过'fitness'函数计算一个综合的评分'fi'
            fi = fitness(np.array(results).reshape(1, -1))  # weighted combination of [P, R, mAP@.5, mAP@.5-.95]
            if fi > best_fitness:
                best_fitness = fi
            # 记录一轮训练后最佳mAP指标
            wandb_logger.end_epoch(best_result=best_fitness == fi)
 
            # Save model 用于保存训练过程中的模型以及相关信息
            #
            # ckpt['epoch']: 记录当前保存模型时的训练轮数（epoch）
            #
            # ckpt['best_fitness']: 记录当前保存模型时的最佳mAP指标
            #
            # ckpt['training_results']: 记录训练过程中保存的结果文件（results.txt）的内容，即训练过程中的指标信息
            #
            # ckpt['model']: 保存当前训练的模型
            # 这里使用deepcopy函数创建一个模型的副本，并将模型转换为半精度浮点数（half），然后存储在ckpt['model']中
            #
            # ckpt['ema']: 保存Exponential Moving Average（EMA）版本的模型
            # 同样使用deepcopy函数创建一个EMA模型的副本，并将模型转换为半精度浮点数（half），然后存储在ckpt['ema']中
            #
            # ckpt['updates']: 记录EMA模型的更新次数。
            #
            # ckpt['optimizer']: 保存当前优化器的状态信息，以便在需要恢复训练时，可以从上次训练的状态继续优化。
            #
            # ckpt['wandb_id']: 记录当前模型的Weights & Biases（W&B）的ID，用于与W&B的记录关联。
            if (not opt.nosave) or (final_epoch and not opt.evolve):  # if save
                ckpt = {'epoch': epoch,
                        'best_fitness': best_fitness,
                        'training_results': results_file.read_text(),
                        'model': deepcopy(model.module if is_parallel(model) else model).half(),
                        'ema': deepcopy(ema.ema).half(),
                        'updates': ema.updates,
                        'optimizer': optimizer.state_dict(),
                        'wandb_id': wandb_logger.wandb_run.id if wandb_logger.wandb else None}
 
                # Save last, best and delete 保存最后模型、最佳模型以及删除模型的操作
                # 保存当前训练轮次(epoch)结束后的模型权重和相关信息到文件'last.pt'中
                torch.save(ckpt, last)
                # 如果当前的模型在该轮次的评估中获得了最佳mAP指标，则将模型权重和相关信息保存到文件中
                if best_fitness == fi:
                    torch.save(ckpt, best)
                # 检查是否启用了日志记录
                if wandb_logger.wandb:
                    if ((epoch + 1) % opt.save_period == 0 and not final_epoch) and opt.save_period != -1:
                        # 在W&B中记录模型的相关信息，包括最后一次训练轮次、模型权重的路径、训练参数等
                        wandb_logger.log_model(
                            last.parent, opt, epoch, fi, best_model=best_fitness == fi)
                # 删除'ckpt'变量，释放模型权重和相关信息所占用的内存
                del ckpt
 
        # end epoch ----------------------------------------------------------------------------------------------------
    # end training 完成绘制结果图表
    # 判断确保只有在rank为-1或0的进程中进行图表绘制，避免多个进程同时绘制造成冲突
    if rank in [-1, 0]:
        # Plots
        if plots:
            # 绘制模型训练和评估的结果图表
            plot_results(save_dir=save_dir)  # save as results.png
            # 检查是否启用W&B日志记录
            if wandb_logger.wandb:
                # 定义要上传到W&B的图像文件列表
                files = ['results.png', 'confusion_matrix.png', *[f'{x}_curve.png' for x in ('F1', 'PR', 'P', 'R')]]
                # 将图像文件列表上传到W&B，并记录名为"Results"的日志项
                wandb_logger.log({"Results": [wandb_logger.wandb.Image(str(save_dir / f), caption=f) for f in files
                                              if (save_dir / f).exists()]})
        # Test best.pt 打印训练的总时长和完成的轮次数，如果数据集是COCO数据集，则执行速度和mAP的测试
        logger.info('%g epochs completed in %.3f hours.\n' % (epoch - start_epoch + 1, (time.time() - t0) / 3600))
        if opt.data.endswith('coco.yaml') and nc == 80:  # if COCO
            for m in (last, best) if best.exists() else (last):  # speed, mAP tests
                results, _, _ = test.test(opt.data,
                                          batch_size=batch_size * 2,
                                          imgsz=imgsz_test,
                                          conf_thres=0.001,
                                          iou_thres=0.7,
                                          model=attempt_load(m, device).half(),
                                          single_cls=opt.single_cls,
                                          dataloader=testloader,
                                          save_dir=save_dir,
                                          save_json=True,
                                          plots=False,
                                          is_coco=is_coco)
 
        # Strip optimizers 最终上传和保存模型，并做一些训练收尾工作
        final = best if best.exists() else last  # final model
        for f in last, best:
            if f.exists():
                # 对指定模型文件'f'移除优化器信息
                strip_optimizer(f)  # strip optimizers
        if opt.bucket:
            os.system(f'gsutil cp {final} gs://{opt.bucket}/weights')  # upload
        if wandb_logger.wandb and not opt.evolve:  # Log the stripped model
            wandb_logger.wandb.log_artifact(str(final), type='model',
                                            name='run_' + wandb_logger.wandb_run.id + '_model',
                                            aliases=['last', 'best', 'stripped'])
        wandb_logger.finish_run()
    # 如果不是主进程，则销毁进程组、释放GPU缓存，并返回测试结果'results'
    else:
        dist.destroy_process_group()
    torch.cuda.empty_cache()
    return results
 
 
if __name__ == '__main__':
    # 训练脚本的主函数部分，使用'argparse'解析命令行参数，我们可以在命令行中指定不同参数来进行模型训练和配置
    parser = argparse.ArgumentParser()
    parser.add_argument('--weights', type=str, default='yolov5s.pt', help='initial weights path')
    parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
    parser.add_argument('--data', type=str, default='data/coco128.yaml', help='data.yaml path')
    parser.add_argument('--hyp', type=str, default='data/hyp.scratch.yaml', help='hyperparameters path')
    parser.add_argument('--epochs', type=int, default=150)
    parser.add_argument('--batch-size', type=int, default=8, help='total batch size for all GPUs')
    parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='[train, test] image sizes')
    parser.add_argument('--rect', action='store_true', help='rectangular training')
    parser.add_argument('--resume', nargs='?', const=True, default=False, help='resume most recent training')
    parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
    parser.add_argument('--notest', action='store_true', help='only test final epoch')
    parser.add_argument('--noautoanchor', action='store_true', help='disable autoanchor check')
    parser.add_argument('--evolve', action='store_true', help='evolve hyperparameters')
    parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
    parser.add_argument('--cache-images', action='store_true', help='cache images for faster training')
    parser.add_argument('--image-weights', action='store_true', help='use weighted image selection for training')
    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')
    parser.add_argument('--single-cls', action='store_true', help='train multi-class data as single-class')
    parser.add_argument('--adam', action='store_true', help='use torch.optim.Adam() optimizer')
    parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')
    parser.add_argument('--local_rank', type=int, default=-1, help='DDP parameter, do not modify')
    parser.add_argument('--workers', type=int, default=8, help='maximum number of dataloader workers')
    parser.add_argument('--project', default='runs/train', help='save to project/name')
    parser.add_argument('--entity', default=None, help='W&B entity')
    parser.add_argument('--name', default='exp', help='save to project/name')
    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
    parser.add_argument('--quad', action='store_true', help='quad dataloader')
    parser.add_argument('--linear-lr', action='store_true', help='linear LR')
    parser.add_argument('--label-smoothing', type=float, default=0.0, help='Label smoothing epsilon')
    parser.add_argument('--upload_dataset', action='store_true', help='Upload dataset as W&B artifact table')
    parser.add_argument('--bbox_interval', type=int, default=-1, help='Set bounding-box image logging interval for W&B')
    parser.add_argument('--save_period', type=int, default=-1, help='Log model after every "save_period" epoch')
    parser.add_argument('--artifact_alias', type=str, default="latest", help='version of dataset artifact to be used')
    opt = parser.parse_args()
########################################################################################################################
    # Set DDP variables
    # 脚本设置了分布式数据并行（DDP）训练所需的环境变量
    # DDP 是一种训练模型的分布式策略，它允许在多个 GPU 上进行模型训练，以加快训练速度
    #
    # 设置全局变量'world_size'，表示并行的GPU数量，默认值为 1，即单GPU训练
    # 如果环境变量中有定义'WORLD_SIZE'，则使用其值作为'world_size'
    opt.world_size = int(os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1
    # 设置全局变量'global_rank'，表示当前进程的全局排名
    # 默认值为 -1。如果环境变量中有定义'RANK'，则使用其值作为'global_rank'
    opt.global_rank = int(os.environ['RANK']) if 'RANK' in os.environ else -1
    #  根据 global_rank 设置日志记录
    set_logging(opt.global_rank)
    if opt.global_rank in [-1, 0]:
        # 检查代码库的Git状态，确保代码库没有未提交的更改
        check_git_status()
        # 检查是否满足了运行所需的Python包依赖项
        check_requirements()
########################################################################################################################
    # Resume 处理恢复训练的逻辑
    #
    # 检查是否可以从W&B中恢复运行
    wandb_run = check_wandb_resume(opt)
    if opt.resume and not wandb_run:  # resume an interrupted run
        # 确定要从哪个检查点恢复训练
        ckpt = opt.resume if isinstance(opt.resume, str) else get_latest_run()  # specified or most recent path
        # 断言检查点文件存在
        assert os.path.isfile(ckpt), 'ERROR: --resume checkpoint does not exist'
        # 保存全局排名和本地排名
        apriori = opt.global_rank, opt.local_rank
        # 加载检查点目录下的'opt.yaml'文件，恢复之前的运行配置
        with open(Path(ckpt).parent.parent / 'opt.yaml') as f:
            opt = argparse.Namespace(**yaml.load(f, Loader=yaml.SafeLoader))  # replace
        opt.cfg, opt.weights, opt.resume, opt.batch_size, opt.global_rank, opt.local_rank = '', ckpt, True, opt.total_batch_size, *apriori  # reinstate
        logger.info('Resuming training from %s' % ckpt)
    else:
        # opt.hyp = opt.hyp or ('hyp.finetune.yaml' if opt.weights else 'hyp.scratch.yaml')
        opt.data, opt.cfg, opt.hyp = check_file(opt.data), check_file(opt.cfg), check_file(opt.hyp)  # check files
        assert len(opt.cfg) or len(opt.weights), 'either --cfg or --weights must be specified'
        opt.img_size.extend([opt.img_size[-1]] * (2 - len(opt.img_size)))  # extend to 2 sizes (train, test)
        opt.name = 'evolve' if opt.evolve else opt.name
        opt.save_dir = increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok | opt.evolve)  # increment run
########################################################################################################################
    # DDP mode 设置分布式数据进行模式
    # DDP是一种并行训练方法，可在多个GPU上同时进行模型训练
    opt.total_batch_size = opt.batch_size
    # 根据用户指定设备和批次大小选择训练设备，返回选定的设备对象
    device = select_device(opt.device, batch_size=opt.batch_size)
    if opt.local_rank != -1:
        # 断言GPU数量大于指定的'opt.local_rank',确保指定的本地GPU索引合法
        assert torch.cuda.device_count() > opt.local_rank
        # 设置当前进程使用的GPU设备
        torch.cuda.set_device(opt.local_rank)
        # 创建CUDA设备对象，用于后续数据和模型的放置
        device = torch.device('cuda', opt.local_rank)
        # 初始化分布式进程组，使用NCCL作为通信后端，并从环境变量中获取初始化方法
        dist.init_process_group(backend='nccl', init_method='env://')  # distributed backend
        assert opt.batch_size % opt.world_size == 0, '--batch-size must be multiple of CUDA device count'
        # 更新'opt.batch_size'，并将其设置为每个GPU应处理的实际批次大小
        opt.batch_size = opt.total_batch_size // opt.world_size
########################################################################################################################
    # Hyperparameters 脚本加载超参数文件
    with open(opt.hyp) as f:
        hyp = yaml.load(f, Loader=yaml.SafeLoader)  # load hyps
########################################################################################################################
    # Train 脚本调用了'train()'函数来开始模型的训练
    logger.info(opt)
    # 将命令行传入的参数'opt'打印出来，用于记录当前训练的配置
    if not opt.evolve:
        tb_writer = None  # init loggers
        if opt.global_rank in [-1, 0]:
            prefix = colorstr('tensorboard: ')
            logger.info(f"{prefix}Start with 'tensorboard --logdir {opt.project}', view at http://localhost:6006/")
            tb_writer = SummaryWriter(opt.save_dir)  # Tensorboard
        # 调用'train()'函数开始进行模型的训练，将括号里的参数都传给了'train()'函数
        train(hyp, opt, device, tb_writer)
########################################################################################################################
    # Evolve hyperparameters (optional)
    # 定义了超参数演化（evolution）的元数据
    # 在超参数演化过程中，每个超参数都有其可变性的范围
    # 元数据'meta'中包含了每个超参数的变异范围，以及变异比例
    # 在演化过程中，每个超参数都会根据其对应的变异比例在其可变性范围内进行随机变异，以生成新的超参数组合
    # 这样可以探索不同超参数组合对模型性能的影响，进而优化模型的表现
    #
    # 以下是各个超参数及其对应的元数据：
    # lr0: 初始学习率的变异范围为 [1e-5, 1e-1]，变异比例为 1
    # lrf: 最终学习率的变异范围为 [0.01, 1.0]，变异比例为 1
    # momentum: SGD 动量或 Adam beta1 的变异范围为 [0.6, 0.98]，变异比例为 0.3
    # weight_decay: 优化器权重衰减（weight decay）的变异范围为 [0.0, 0.001]，变异比例为 1
    # 其他超参数以此类推
    else:
        # Hyperparameter evolution metadata (mutation scale 0-1, lower_limit, upper_limit)
        meta = {'lr0': (1, 1e-5, 1e-1),  # initial learning rate (SGD=1E-2, Adam=1E-3)
                'lrf': (1, 0.01, 1.0),  # final OneCycleLR learning rate (lr0 * lrf)
                'momentum': (0.3, 0.6, 0.98),  # SGD momentum/Adam beta1
                'weight_decay': (1, 0.0, 0.001),  # optimizer weight decay
                'warmup_epochs': (1, 0.0, 5.0),  # warmup epochs (fractions ok)
                'warmup_momentum': (1, 0.0, 0.95),  # warmup initial momentum
                'warmup_bias_lr': (1, 0.0, 0.2),  # warmup initial bias lr
                'box': (1, 0.02, 0.2),  # box loss gain
                'cls': (1, 0.2, 4.0),  # cls loss gain
                'cls_pw': (1, 0.5, 2.0),  # cls BCELoss positive_weight
                'obj': (1, 0.2, 4.0),  # obj loss gain (scale with pixels)
                'obj_pw': (1, 0.5, 2.0),  # obj BCELoss positive_weight
                'iou_t': (0, 0.1, 0.7),  # IoU training threshold
                'anchor_t': (1, 2.0, 8.0),  # anchor-multiple threshold
                'anchors': (2, 2.0, 10.0),  # anchors per output grid (0 to ignore)
                'fl_gamma': (0, 0.0, 2.0),  # focal loss gamma (efficientDet default gamma=1.5)
                'hsv_h': (1, 0.0, 0.1),  # image HSV-Hue augmentation (fraction)
                'hsv_s': (1, 0.0, 0.9),  # image HSV-Saturation augmentation (fraction)
                'hsv_v': (1, 0.0, 0.9),  # image HSV-Value augmentation (fraction)
                'degrees': (1, 0.0, 45.0),  # image rotation (+/- deg)
                'translate': (1, 0.0, 0.9),  # image translation (+/- fraction)
                'scale': (1, 0.0, 0.9),  # image scale (+/- gain)
                'shear': (1, 0.0, 10.0),  # image shear (+/- deg)
                'perspective': (0, 0.0, 0.001),  # image perspective (+/- fraction), range 0-0.001
                'flipud': (1, 0.0, 1.0),  # image flip up-down (probability)
                'fliplr': (0, 0.0, 1.0),  # image flip left-right (probability)
                'mosaic': (1, 0.0, 1.0),  # image mixup (probability)
                'mixup': (1, 0.0, 1.0)}  # image mixup (probability)
 
        # 设置超参数演化模式的相关参数
        assert opt.local_rank == -1, 'DDP mode not implemented for --evolve'
        opt.notest, opt.nosave = True, True  # only test/save final epoch
        # ei = [isinstance(x, (int, float)) for x in hyp.values()]  # evolvable indices
        yaml_file = Path(opt.save_dir) / 'hyp_evolved.yaml'  # save best result here
        if opt.bucket:
            os.system('gsutil cp gs://%s/evolve.txt .' % opt.bucket)  # download evolve.txt if exists
 
        # 进行超参数演化的进化过程
        # 在进化的过程中，会尝试进行一系列的变异和选择，以找到更优秀的超参数组合
        # 这里使用遗传算法中的父代选择方法，选择用于变异的父代个体
        for _ in range(300):  # generations to evolve
            if Path('evolve.txt').exists():  # if evolve.txt exists: select best hyps and mutate
                # Select parent(s)
                parent = 'single'  # parent selection method: 'single' or 'weighted'
                x = np.loadtxt('evolve.txt', ndmin=2)
                n = min(5, len(x))  # number of previous results to consider
                x = x[np.argsort(-fitness(x))][:n]  # top n mutations
                w = fitness(x) - fitness(x).min()  # weights
                if parent == 'single' or len(x) == 1:
                    # x = x[random.randint(0, n - 1)]  # random selection
                    x = x[random.choices(range(n), weights=w)[0]]  # weighted selection
                elif parent == 'weighted':
                    x = (x * w.reshape(n, 1)).sum(0) / w.sum()  # weighted combination
 
                # Mutate
                # 实现了超参数的变异操作
                # 在超参数演化中，对于每个超参数，根据'meta'中定义的变异概率和标准差，以及当前超参数的取值范围，进行随机变异
                # m为变异概率，s为标准差，g为每个超参数对于的变异尺度，ng为超参数的数量，v为长度为ng的数组
                mp, s = 0.8, 0.2  # mutation probability, sigma
                npr = np.random
                npr.seed(int(time.time()))
                g = np.array([x[0] for x in meta.values()])  # gains 0-1
                ng = len(meta)
                v = np.ones(ng)
                while all(v == 1):  # mutate until a change occurs (prevent duplicates)
                    v = (g * (npr.random(ng) < mp) * npr.randn(ng) * npr.random() * s + 1).clip(0.3, 3.0)
                for i, k in enumerate(hyp.keys()):  # plt.hist(v.ravel(), 300)
                    hyp[k] = float(x[i + 7] * v[i])  # mutate
 
            # Constrain to limits
            # 对超参数进行限制，确保它们在合理的取值范围之内
            for k, v in meta.items():
                hyp[k] = max(hyp[k], v[1])  # lower limit
                hyp[k] = min(hyp[k], v[2])  # upper limit
                hyp[k] = round(hyp[k], 5)  # significant digits
 
            # Train mutation
            # 在进行超参数变异后，代码调用'train'函数使用变异后的超参数'hyp'进行训练，并返回训练得到的结果
            # 这些结果保存在'results'变量中，并且在代码的最后，将其转换为标量值，并存储在'output'变量中
            results = train(hyp.copy(), opt, device)
 
            output = results.item()
 
            # Write mutation results
            # 在代码的最后部分，它调用名为'print_mutation'的函数，将变异的超参数'hyp'和相应的训练结果'output'写入到'yaml_file'文件中
            # 这个函数可能是用来记录超参数的变异历史和相应的训练结果，以便进行后续的超参数优化。
            print_mutation(hyp.copy(), output, yaml_file, opt.bucket)
 
        # Plot results
        # 在这里，代码调用了'plot_evolution"函数来绘制超参数的进化历史，并输出了超参数优化的结果以及训练新模型时的命令示例
        plot_evolution(yaml_file)
        print(f'Hyperparameter evolution complete. Best results saved as: {yaml_file}\n'
              f'Command to train a new model with these hyperparameters: $ python train.py --hyp {yaml_file}')
 
        # 综合来看，这个 Python 脚本的主要功能是进行目标检测模型的训练，并支持以下功能：
        #
        # 基于给定超参数进行训练
        # 恢复中断的训练过程
        # 使用分布式数据并行（DDP）模式进行多GPU训练
        # 自动混合精度（AMP）加速
        # 数据增强和多尺度训练
        # 保存模型、日志和结果文件
        # 支持使用命令行参数配置超参数和训练选项
        # 支持超参数自动优化（进化算法）
        #
        # 它通过输出'print'语句通知用户超参数优化已经完成，并显示了用于训练新模型的命令示例

常见的训练脚本参数说明：

# 常见的参数说明：
#
# --weights: 初始权重路径，默认值为 'yolov5s.pt'。
#
# --cfg: 模型配置文件路径，默认为空字符串。
#
# --data: 数据集配置文件路径，默认为 'data/coco128.yaml'。
#
# --hyp: 超参数文件路径，默认为 'data/hyp.scratch.yaml'。
#
# --epochs: 训练的总轮数，默认为 150。
#
# --batch-size: 所有 GPU 的总批量大小，默认为 8。
#
# --img-size: 图像大小，一个包含训练和测试图像大小的列表，默认为 [640, 640]。
#
# --rect: 是否使用矩形训练。
#
# --resume: 是否从最近的训练中恢复。
#
# --nosave: 只保存最终检查点，不保存中间检查点。
#
# --notest: 只在最后一个 epoch 进行测试。
#
# --noautoanchor: 禁用自动锚框检查。
#
# --evolve: 进化（evolve）超参数。
#
# --bucket: gsutil bucket。
#
# --cache-images: 缓存图像以加快训练速度。
#
# --image-weights: 使用加权图像选择进行训练。
#
# --device: 使用的计算设备，例如 'cuda:0' 或 '0,1,2' 或 'cpu'。
#
# --multi-scale: 图像大小是否变化（在原始图像大小的上下波动50%）。
#
# --single-cls: 将多类别数据训练为单类别。
#
# --adam: 使用 torch.optim.Adam() 优化器。
#
# --sync-bn: 在 DDP（分布式数据并行）模式下使用 SyncBatchNorm。
#
# --local_rank: DDP 参数，不要修改。
#
# --workers: 数据加载器的最大工作线程数。
#
# --project: 保存到项目的名称。
#
# --entity: W&B（Weights & Biases）实体名称。
#
# --name: 保存到项目的名称。
#
# --exist-ok: 是否允许使用现有的项目/名称，不增加计数。
#
# --quad: 使用四通道数据加载器。
#
# --linear-lr: 使用线性学习率（Linear LR）。
#
# --label-smoothing: 标签平滑参数 epsilon。
#
# --upload_dataset: 将数据集上传为 W&B artifact 表格。
#
# --bbox_interval: 设置 W&B 中边界框图像日志间隔。
#
# --save_period: 在每个 "save_period" 轮之后记录模型。
#
# --artifact_alias: 要使用的数据集 artifact 的版本别名