yolov8用法及源码解析 (按照训练流程进行梳理）

这里使用python环境训练而不使用ultralytics包，内容参考docs.ultralytics

1.首先建立一个训练的文件

from ultralytics import YOLO

# 建议添加一个main作为程序入口，可以避免某些多线程报错
if __name__ == '__main__':

    ## 加载模型（三选一）
    # 1.使用配置文件构建模型
    model = YOLO("yolov8n.yaml")  # build a new model from scratch
    # 2.使用预训练模型构建
    model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)
    # 3.使用预训练模型
    model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # 从配置构建并传递权重#

    ## 使用模型

    # 训练,可以传入的传参参考ultralytics/cfg/default.yaml里面的Train settings部分
    model.train(data="coco128.yaml", epochs=3)  # train the model

    # 评估
    metrics = model.val()  # evaluate model performance on the validation set

    # 推理，可以传入的传参参考ultralytics/cfg/default.yaml里面的Prediction settings部分
    results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
    # 导出onnx格式模型文件
    path = model.export(format="onnx")  # export the model to ONNX format

2.加载模型部分解析

2.1使用配置文件加载

model = YOLO("yolov8n.yaml")，会从Model中的_new方法构建模型

    # 根据yaml配置文件初始化一个模型
    def _new(self, cfg: str, task=None, model=None, verbose=True):
        """
        Initializes a new model and infers the task type from the model definitions.

        Args:
            cfg (str): model configuration file
            task (str | None): model task
            model (BaseModel): Customized model.
            verbose (bool): display model info on load
        """
        cfg_dict = yaml_model_load(cfg)     # 加载yaml配置文件
        self.cfg = cfg      # self.cfg存储模型配置文件路径

        # 如果传入的任务类型参数不为空，则将其赋值给实例变量task；调用guess_model_task函数从模型配置文件中head或文件名猜测任务类型
        self.task = task or guess_model_task(cfg_dict)
        # model为none，执行smart_load方法返回任务模型的类(ClassificationModel/DetectionModel等)
        model = model or self.smart_load('model')
        # 使用模型配置字典,verbose和RANK实例化上行任务模型的类。verbose是日志显示
        self.model = model(cfg_dict, verbose=verbose and RANK == -1)  # build model
        # 将配置文件路径保存到self.overrides字典中
        self.overrides['model'] = self.cfg

        # Below added to allow export from yamls
        # 将默认配置文件ROOT / 'cfg/default.yaml'参数字典与self.overrides字典合并,即为default.yaml中的model赋值了。
        args = {**DEFAULT_CFG_DICT, **self.overrides}  # combine model and default args, preferring model args
        # 给实例化的self.model添加args属性，args为一个配置参数的字典
        self.model.args = {k: v for k, v in args.items() if k in DEFAULT_CFG_KEYS}  # attach args to model
        # 给实例化的self.model添加task属性
        self.model.task = self.task

2.2使用预训练模型加载

model = YOLO("yolov8n.pt")，会从Model中的_load方法构建模型。

    # 根据.pt权重文件初始化一个模型
    def _load(self, weights: str, task=None):
        """
        Initializes a new model and infers the task type from the model head.

        Args:
            weights (str): model checkpoint to be loaded
            task (str | None): model task
        """
        # 获取weights文件后缀名
        suffix = Path(weights).suffix
        # 如果是.pt，调用attempt_load_one_weight(weights)方法尝试加载该模型
        if suffix == '.pt':
            self.model, self.ckpt = attempt_load_one_weight(weights)
            # 从模型参数中获取任务类型 self.task，（eg：detect）
            self.task = self.model.args['task']
            # 调用_reset_ckpt_args方法保存{“data”：值,"imgsz":值,"single_cls":值 ,"task":值}到self.overrides字典和更新self.model.args
            self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
            # 模型路径赋值给self.ckpt_path
            self.ckpt_path = self.model.pt_path
        # 不是“.pt”后缀的权重文件
        else:
            # 检查文件是否存在，如果不存在，则尝试下载或查找文件，返回文件路径。
            weights = check_file(weights)
            self.model, self.ckpt = weights, None
            # 调用guess_model_task从文件名推测任务名
            self.task = task or guess_model_task(weights)
            # 权重文件路径赋值给self.ckpt_path
            self.ckpt_path = weights

        # 模型路径 weights 和任务类型 self.task 分别存储在 self.overrides字典中
        self.overrides['model'] = weights
        self.overrides['task'] = self.task

 2.3从配置文件构建模型并传递权重

model = YOLO('yolov8n.yaml').load('yolov8n.pt') ，会从Model中的_new方法构建模型，并调用load方法将.pt文件模型参数加载到模型中。

    @smart_inference_mode()
    def load(self, weights='yolov8n.pt'):
        # 将指定权重文件中的参数加载到模型中。使用eg:model = YOLO('yolov8n.yaml').load('yolov8n.pt')构建模型时用到
        """
        Transfers parameters with matching names and shapes from 'weights' to model.
        """
        # 检查self.model 是PyTorch 模型
        self._check_is_pytorch_model()

        # 如果传入的 weights 参数是字符串路径或 Path 对象，
        # 则调用 attempt_load_one_weight 方法尝试加载单个权重文件。
        # 将加载后的模型赋值给 weights，并将当前模型的相关信息(epoch,best_fitness,model,ema,train_args...)赋值给 self.ckpt。
        if isinstance(weights, (str, Path)):
            weights, self.ckpt = attempt_load_one_weight(weights)
        # 将weights中与self.model模型参数名称和形状匹配的参数加载到模型中
        self.model.load(weights)
        return self

流程详解 

程序进入ultralytics/models/yolo/model.py的YOLO类中执行初始化，继承Model类

# Ultralytics YOLO 🚀, AGPL-3.0 license

from ultralytics.engine.model import Model
from ultralytics.models import yolo  # noqa
from ultralytics.nn.tasks import ClassificationModel, DetectionModel, PoseModel, SegmentationModel

# 继承Model
class YOLO(Model):
    """
    YOLO (You Only Look Once) object detection model.
    """
    # 重写Model中的task_map函数,
    # 返回一个{“任务名”：{"model":任务模型的类, "trainer":任务的trainer类, validator:任务的validator类, "predictor":任务的validator类}}字典,
    @property
    def task_map(self):
        """Map head to model, trainer, validator, and predictor classes"""
        return {
            # 分类任务
            'classify': {
                'model': ClassificationModel,
                'trainer': yolo.classify.ClassificationTrainer,
                'validator': yolo.classify.ClassificationValidator,
                'predictor': yolo.classify.ClassificationPredictor, },
            # 检测任务
            'detect': {
                'model': DetectionModel,
                'trainer': yolo.detect.DetectionTrainer,
                'validator': yolo.detect.DetectionValidator,
                'predictor': yolo.detect.DetectionPredictor, },
            # 分割任务
            'segment': {
                'model': SegmentationModel,
                'trainer': yolo.segment.SegmentationTrainer,
                'validator': yolo.segment.SegmentationValidator,
                'predictor': yolo.segment.SegmentationPredictor, },
            # 姿态估计任务
            'pose': {
                'model': PoseModel,
                'trainer': yolo.pose.PoseTrainer,
                'validator': yolo.pose.PoseValidator,
                'predictor': yolo.pose.PosePredictor, }, }

 在ultralytics/engine/model.py文件中的Model类中完成model的构建。

class Model:
    """
    A base model class to unify apis for all the models.

    Args:
        model (str, Path): Path to the model file to load or create.
        task (Any, optional): Task type for the YOLO model. Defaults to None.

    Attributes:
        predictor (Any): The predictor object.
        model (Any): The model object.
        trainer (Any): The trainer object.
        task (str): The type of model task.
        ckpt (Any): The checkpoint object if the model loaded from *.pt file.
        cfg (str): The model configuration if loaded from *.yaml file.
        ckpt_path (str): The checkpoint file path.
        overrides (dict): Overrides for the trainer object.
        metrics (Any): The data for metrics.

    Methods:
        __call__(source=None, stream=False, **kwargs):
            Alias for the predict method.
        _new(cfg:str, verbose:bool=True) -> None:
            Initializes a new model and infers the task type from the model definitions.
        _load(weights:str, task:str='') -> None:
            Initializes a new model and infers the task type from the model head.
        _check_is_pytorch_model() -> None:
            Raises TypeError if the model is not a PyTorch model.
        reset() -> None:
            Resets the model modules.
        info(verbose:bool=False) -> None:
            Logs the model info.
        fuse() -> None:
            Fuses the model for faster inference.
        predict(source=None, stream=False, **kwargs) -> List[ultralytics.engine.results.Results]:
            Performs prediction using the YOLO model.

    Returns:
        list(ultralytics.engine.results.Results): The prediction results.
    """

    # 初始化
    def __init__(self, model: Union[str, Path] = 'yolov8n.pt', task=None) -> None:
        # model:接受字符串或路径对象作为参数,
        # task:任务名
        """
        Initializes the YOLO model.

        Args:
            model (Union[str, Path], optional): Path or name of the model to load or create. Defaults to 'yolov8n.pt'.
            task (Any, optional): Task type for the YOLO model. Defaults to None.
        """
        self.callbacks = callbacks.get_default_callbacks()  # 创建default_callbacks字典的副本。
        self.predictor = None  # reuse predictor 预测器默认None
        self.model = None  # model object 模型默认None
        self.trainer = None  # trainer object   训练器默认none
        self.ckpt = None  # if loaded from *.pt 模型权重文件默认none
        self.cfg = None  # if loaded from *.yaml 模型配置文件默认none
        self.ckpt_path = None   # 模型权重文件路径默认none
        self.overrides = {}  # overrides for trainer object    用于记录一些所需变量及参数如模型路径、数据路径、mode、超参数等。
        self.metrics = None  # validation/training metrics      存储训练和验证过程中的指标（metrics）
        self.session = None  # HUB session
        self.task = task  # task type    任务类型
        model = str(model).strip()  # strip spaces 使用 strip()删除model路径两端的空格

        # Check if Ultralytics HUB model from https://hub.ultralytics.com
        # 使用is_hub_model成员函数判断是 hub 模型，则导入 HUBTrainingSession类处理模型
        if self.is_hub_model(model):
            from ultralytics.hub.session import HUBTrainingSession
            self.session = HUBTrainingSession(model)
            model = self.session.model_file


        # Load or create new YOLO model
        # 获取model路径的后缀
        suffix = Path(model).suffix
        # 判断语句检查 suffix 是否为空，并且检查 model 的文件名是否在 GITHUB_ASSET_STEMS 列表中
        if not suffix and Path(model).stem in GITHUB_ASSET_STEMS:
            # 如果model没有指定后缀且是支持的模型名称，那么将通过 with_suffix() 方法将 .pt 后缀添加到 model上，并将 suffix 设置为 '.pt'。
            model, suffix = Path(model).with_suffix('.pt'), '.pt'  # add suffix, i.e. yolov8n -> yolov8n.pt

        # 模型文件是 YAML 格式的配置文件，接下来会执行 _new() 方法进行模型的初始化
        if suffix in ('.yaml', '.yml'):
            self._new(model, task)
        # 模型文件是.pt 文件，执行 _load() 方法加载预训练的权重。
        else:
            self._load(model, task)

    def __call__(self, source=None, stream=False, **kwargs):
        """Calls the 'predict' function with given arguments to perform object detection."""
        # 调用对象实例时执行predict函数
        return self.predict(source, stream, **kwargs)

    @staticmethod
    def is_hub_model(model):
        # 检查模型是否是https://hub.ultralytics.com/models/中的模型

        """Check if the provided model is a HUB model."""
        return any((
            model.startswith(f'{HUB_WEB_ROOT}/models/'),  # i.e. https://hub.ultralytics.com/models/MODEL_ID
            [len(x) for x in model.split('_')] == [42, 20],  # APIKEY_MODELID
            len(model) == 20 and not Path(model).exists() and all(x not in model for x in './\\')))  # MODELID

    # 根据yaml配置文件初始化一个模型
    def _new(self, cfg: str, task=None, model=None, verbose=True):
        """
        Initializes a new model and infers the task type from the model definitions.

        Args:
            cfg (str): model configuration file
            task (str | None): model task
            model (BaseModel): Customized model.
            verbose (bool): display model info on load
        """
        cfg_dict = yaml_model_load(cfg)     # 加载yaml配置文件
        self.cfg = cfg      # self.cfg存储模型配置文件路径

        # 如果传入的任务类型参数不为空，则将其赋值给实例变量task；调用guess_model_task函数从模型配置文件中head或文件名猜测任务类型
        self.task = task or guess_model_task(cfg_dict)
        # model为none，执行smart_load方法返回任务模型的类(ClassificationModel/DetectionModel等)
        model = model or self.smart_load('model')
        # 使用模型配置字典,verbose和RANK实例化上行任务模型的类。verbose是日志显示
        self.model = model(cfg_dict, verbose=verbose and RANK == -1)  # build model
        # 将配置文件路径保存到self.overrides字典中
        self.overrides['model'] = self.cfg

        # Below added to allow export from yamls
        # 将默认配置文件ROOT / 'cfg/default.yaml'参数字典与self.overrides字典合并,即为default.yaml中的model赋值了。
        args = {**DEFAULT_CFG_DICT, **self.overrides}  # combine model and default args, preferring model args
        # 给实例化的self.model添加args属性，args为一个配置参数的字典
        self.model.args = {k: v for k, v in args.items() if k in DEFAULT_CFG_KEYS}  # attach args to model
        # 给实例化的self.model添加task属性
        self.model.task = self.task

    # 根据.pt权重文件初始化一个模型
    def _load(self, weights: str, task=None):
        """
        Initializes a new model and infers the task type from the model head.

        Args:
            weights (str): model checkpoint to be loaded
            task (str | None): model task
        """
        # 获取weights文件后缀名
        suffix = Path(weights).suffix
        # 如果是.pt，调用attempt_load_one_weight(weights)方法尝试加载该模型
        if suffix == '.pt':
            self.model, self.ckpt = attempt_load_one_weight(weights)
            # 从模型参数中获取任务类型 self.task，（eg：detect）
            self.task = self.model.args['task']
            # 调用_reset_ckpt_args方法保存{“data”：值,"imgsz":值,"single_cls":值 ,"task":值}到self.overrides字典和更新self.model.args
            self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)
            # 模型路径赋值给self.ckpt_path
            self.ckpt_path = self.model.pt_path
        # 不是“.pt”后缀的权重文件
        else:
            # 检查文件是否存在，如果不存在，则尝试下载或查找文件，返回文件路径。
            weights = check_file(weights)
            self.model, self.ckpt = weights, None
            # 调用guess_model_task从文件名推测任务名
            self.task = task or guess_model_task(weights)
            # 权重文件路径赋值给self.ckpt_path
            self.ckpt_path = weights

        # 模型路径 weights 和任务类型 self.task 分别存储在 self.overrides字典中
        self.overrides['model'] = weights
        self.overrides['task'] = self.task

    def _check_is_pytorch_model(self):
        # 检查模型是否为 PyTorch 模型
        """
        Raises TypeError is model is not a PyTorch model
        """
        # 检查是否为以 .pt 结尾的路径
        pt_str = isinstance(self.model, (str, Path)) and Path(self.model).suffix == '.pt'
        # 检查 self.model 是否为 nn.Module 的实例，即判断是否为 PyTorch 模型对象
        pt_module = isinstance(self.model, nn.Module)
        # 只要某个不符合要求便抛出异常。
        if not (pt_module or pt_str):
            raise TypeError(f"model='{self.model}' must be a *.pt PyTorch model, but is a different type. "
                            f'PyTorch models can be used to train, val, predict and export, i.e. '
                            f"'yolo export model=yolov8n.pt', but exported formats like ONNX, TensorRT etc. only "
                            f"support 'predict' and 'val' modes, i.e. 'yolo predict model=yolov8n.onnx'.")

    @smart_inference_mode()
    def reset_weights(self):
        # 重置模型的模块参数为随机初始化的值
        """
        Resets the model modules parameters to randomly initialized values, losing all training information.
        """
        # 调用_check_is_pytorch_model 方法，确保 self.model 是合法的 PyTorch 模型。
        self._check_is_pytorch_model()
        # 通过迭代 self.model.modules()，对模型的每个模块进行处理。如果当前模块具有 reset_parameters属性，则调用该方法重置参数为随机初始化的值。
        for m in self.model.modules():
            if hasattr(m, 'reset_parameters'):
                m.reset_parameters()
        # 模型的每个参数需要进行梯度计算
        for p in self.model.parameters():
            p.requires_grad = True
        return self

    @smart_inference_mode()
    def load(self, weights='yolov8n.pt'):
        # 将指定权重文件中的参数加载到模型中。使用eg:model = YOLO('yolov8n.yaml').load('yolov8n.pt')构建模型时用到
        """
        Transfers parameters with matching names and shapes from 'weights' to model.
        """
        # 检查self.model 是PyTorch 模型
        self._check_is_pytorch_model()

        # 如果传入的 weights 参数是字符串路径或 Path 对象，
        # 则调用 attempt_load_one_weight 方法尝试加载单个权重文件。
        # 将加载后的模型赋值给 weights，并将当前模型的相关信息(epoch,best_fitness,model,ema,train_args...)赋值给 self.ckpt。
        if isinstance(weights, (str, Path)):
            weights, self.ckpt = attempt_load_one_weight(weights)
        # 将weights中与self.model模型参数名称和形状匹配的参数加载到模型中
        self.model.load(weights)
        return self

    def info(self, detailed=False, verbose=True):
        # 输出模型的信息
        """
        Logs model info.

        Args:
            detailed (bool): Show detailed information about model.
            verbose (bool): Controls verbosity.
        """
        self._check_is_pytorch_model()
        return self.model.info(detailed=detailed, verbose=verbose)

    def fuse(self):
        # 将模型中的 Conv2d 和 BatchNorm2d 层融合。提速作用。
        """Fuse PyTorch Conv2d and BatchNorm2d layers."""
        self._check_is_pytorch_model()
        self.model.fuse()


    @smart_inference_mode()
    def predict(self, source=None, stream=False, predictor=None, **kwargs):
        # 推理部分，用法eg：model.predict(source="datasets/images/val",save=True,save_conf=True,save_txt=True,name='output')
        # 参数参考default.yaml文件中Prediction settings部分
        """
        Perform prediction using the YOLO model.
        Args:
            source (str | int | PIL | np.ndarray): The source of the image to make predictions on.
                          Accepts all source types accepted by the YOLO model.
            stream (bool): Whether to stream the predictions or not. Defaults to False.
            predictor (BasePredictor): Customized predictor.
            **kwargs : Additional keyword arguments passed to the predictor.
                       Check the 'configuration' section in the documentation for all available options.

        Returns:
            (List[ultralytics.engine.results.Results]): The prediction results.
        """
        # 如果没有提供 source 参数，则使用默认的图像源
        if source is None:
            source = ROOT / 'assets' if is_git_dir() else 'https://ultralytics.com/images/bus.jpg'
            LOGGER.warning(f"WARNING ⚠️ 'source' is missing. Using 'source={source}'.")

        # 是否为命令行界面（cli即command line interface）
        is_cli = (sys.argv[0].endswith('yolo') or sys.argv[0].endswith('ultralytics')) and any(
            x in sys.argv for x in ('predict', 'track', 'mode=predict', 'mode=track'))

        # Check prompts for SAM/FastSAM
        # 如果传入参数kwargs中存在prompts的键就将其值赋值给prompts，没有就将none赋给prompts
        prompts = kwargs.pop('prompts', None)
        # 复制 self.overrides 的内容给overrides，{'model': 'yolov8n.yaml'}
        overrides = self.overrides.copy()
        # 置信度 设置为 0.25
        overrides['conf'] = 0.25
        # 将 kwargs 中的参数更新到 overrides 中。（更新conf，添加其他传入的参数）
        overrides.update(kwargs)  # prefer kwargs
        # 将 mode 参数设置为 'predict'（如果未指定的话）
        overrides['mode'] = kwargs.get('mode', 'predict')
        # 确保 mode 参数的值为 'track' 或 'predict'
        assert overrides['mode'] in ['track', 'predict']
        if not is_cli:
            # 将 save 参数设置为 'False'（如果未指定的话）
            overrides['save'] = kwargs.get('save', False)  # do not save by default if called in Python

        if not self.predictor:  # 默认self.predictor为none
            self.task = overrides.get('task') or self.task
            # 使用默认的predictor对象还是加载自定义的predictor对象(如果传入了predictor)
            predictor = predictor or self.smart_load('predictor')
            # 为predictor传入参数创建self.predictor预测器对象
            self.predictor = predictor(overrides=overrides, _callbacks=self.callbacks)
            # 设置predictor模型
            self.predictor.setup_model(model=self.model, verbose=is_cli)
        else:  # only update args if predictor is already setup
            # 预测器对象已经存在，则更新预测器对象的参数
            self.predictor.args = get_cfg(self.predictor.args, overrides)
            # 预测器对象的保存目录
            if 'project' in overrides or 'name' in overrides:
                self.predictor.save_dir = self.predictor.get_save_dir()
        # Set prompts for SAM/FastSAM 设置 SAM/FastSAM 的提示信息。
        if len and hasattr(self.predictor, 'set_prompts'):
            self.predictor.set_prompts(prompts)
        # predict_cli 方法用于在命令行界面（CLI）中进行预测
        return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream)


    def track(self, source=None, stream=False, persist=False, **kwargs):
        # 执行目标跟踪，用法eg: model.track(source=".avi", show=True,  save=True)
        """
        Perform object tracking on the input source using the registered trackers.

        Args:
            source (str, optional): The input source for object tracking. Can be a file path or a video stream.
            stream (bool, optional): Whether the input source is a video stream. Defaults to False.
            persist (bool, optional): Whether to persist the trackers if they already exist. Defaults to False.
            **kwargs (optional): Additional keyword arguments for the tracking process.

        Returns:
            (List[ultralytics.engine.results.Results]): The tracking results.

        """
        # 如果预测器对象没有属性 trackers，则会导入register_tracker
        if not hasattr(self.predictor, 'trackers'):
            from ultralytics.trackers import register_tracker
            register_tracker(self, persist)
        # ByteTrack-based method needs low confidence predictions as input
        # 将 置信度conf参数设置为 '0.1'（如果未指定的话）
        conf = kwargs.get('conf') or 0.1
        kwargs['conf'] = conf
        # 将 mode值设置为 'track'
        kwargs['mode'] = 'track'
        # 返回目标跟踪predictor
        return self.predict(source=source, stream=stream, **kwargs)

    @smart_inference_mode()
    def val(self, data=None, validator=None, **kwargs):
        # 验证 用法eg: metrics = model.val()
        """
        Validate a model on a given dataset.

        Args:
            data (str): The dataset to validate on. Accepts all formats accepted by yolo
            validator (BaseValidator): Customized validator.
            **kwargs : Any other args accepted by the validators. To see all args check 'configuration' section in docs
        """
        overrides = self.overrides.copy()
        # 默认使用rect，减少padding的冗余信息，能加速推理
        overrides['rect'] = True  # rect batches as default
        # 更新overrides
        overrides.update(kwargs)
        # mode值设置为'val'
        overrides['mode'] = 'val'
        # 使用训练模型中的图像尺寸imgsz的值（如果没有指定图像尺寸imgsz）
        if overrides.get('imgsz') is None:
            overrides['imgsz'] = self.model.args['imgsz']  # use trained imgsz unless custom value is passed
        # 调用get_cfg加载和合并DEFAULT_CFG和overrides配置数据
        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
        # data 赋值给 args.data，或者使用默认的数据集。
        args.data = data or args.data
        if 'task' in overrides:
            self.task = args.task
        else:
            args.task = self.task
        # 加载validator
        validator = validator or self.smart_load('validator')
        # 图像尺寸不是步长的倍数，则将其更新为最接近步长的倍数且大于或等于给定下限值的值。
        args.imgsz = check_imgsz(args.imgsz, max_dim=1)
        # 实例化验证器validator
        validator = validator(args=args, _callbacks=self.callbacks)
        validator(model=self.model)
        # validator.metrics用于计算目标检测模型的精确度、召回率和平均精确度（mAP）等检测指标
        self.metrics = validator.metrics
        return validator.metrics

    @smart_inference_mode()
    def benchmark(self, **kwargs):
        # 测试所有导出格式，最终运行结果会显示可以导出的模型类型，每个类型导出的文件大小，指标和推理时间
        # 用法：eg benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0))

        """
        Benchmark a model on all export formats.

        Args:
            **kwargs : Any other args accepted by the validators. To see all args check 'configuration' section in docs
        """

        self._check_is_pytorch_model()
        from ultralytics.utils.benchmarks import benchmark
        overrides = self.model.args.copy()
        # 将传入的 kwargs 更新到 overrides 中
        overrides.update(kwargs)
        overrides['mode'] = 'benchmark'
        # 使用默认配置字典 DEFAULT_CFG_DICT 填充缺失的 overrides 键
        overrides = {**DEFAULT_CFG_DICT, **overrides}  # fill in missing overrides keys with defaults
        # 返回基准测试结果，模型类型，每个类型导出的文件大小，在data上的评估指标、推理时间
        return benchmark(
            model=self,
            data=kwargs.get('data'),  # if no 'data' argument passed set data=None for default datasets
            imgsz=overrides['imgsz'],
            half=overrides['half'],
            int8=overrides['int8'],
            device=overrides['device'],
            verbose=kwargs.get('verbose'))

    # 导出模型
    def export(self, **kwargs):
        # 用法：model.export(format="onnx",dynamic=Ture, opset=12)
        # 相关参数：参考https://docs.ultralytics.com/modes/export/
        # format:导出的格式，(ONNX,TorchScript,TensorRT,PaddlePaddle,TF SavedModel,TF GraphDef,TF Lite等，)
        # imgsz:图像尺寸
        # keras:(False)使用Keras导出TF SavedModel。
        # optimize:(False) TorchScript：针对移动设备进行优化。
        # half:(False)半精度
        # int8:(False)int8数据量相对小，计算速度可以更快
        # dynamic:（False）支持动态输入的ONNX/TF/TensorRT
        # simplify:(False)简化onnx模型
        # opset:(None) 默认最新版
        # workspace:（4） TensorRT workspace size (GB)
        # nms:CoreML添加 NMS非极大值抑制
        """
        Export model.

        Args:
            **kwargs : Any other args accepted by the predictors. To see all args check 'configuration' section in docs
        """
        #  检查当前模型是否使用的是 PyTorch 框架
        self._check_is_pytorch_model()
        # 复制模型中的参数字典（overrides）
        overrides = self.overrides.copy()
        # 根据传入的kwargs更新
        overrides.update(kwargs)
        # 设置mode为export模式
        overrides['mode'] = 'export'
        #  如果没有设置输入图像大小，则使用训练时的图像大小
        if overrides.get('imgsz') is None:
            overrides['imgsz'] = self.model.args['imgsz']  # use trained imgsz unless custom value is passed
        # 如果没有设置 batch size，则默认为 1
        if 'batch' not in kwargs:
            overrides['batch'] = 1  # default to 1 if not modified
        # 如果没有设置数据集，则默认为 None。
        if 'data' not in kwargs:
            overrides['data'] = None  # default to None if not modified (avoid int8 calibration with coco.yaml)
        # 调用get_cfg加载和合并DEFAULT_CFG和overrides配置数据
        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
        # 任务类型
        args.task = self.task
        # 返回一个 Exporter 对象，该对象用于将模型导出为 ONNX 或 TorchScript等格式
        return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model)

    def train(self, trainer=None, **kwargs):
        # 模型的训练
        """
        Trains the model on a given dataset.

        Args:
            trainer (BaseTrainer, optional): Customized trainer.
            **kwargs (Any): Any number of arguments representing the training configuration.
        """
        # 先检查模型是否是 PyTorch 模型。
        self._check_is_pytorch_model()
        if self.session:  # Ultralytics HUB session
            if any(kwargs):
                LOGGER.warning('WARNING ⚠️ using HUB training arguments, ignoring local training arguments.')
            kwargs = self.session.train_args
        # 检查Pip 更新
        check_pip_update_available()
        # 复制模型中的参数字典（overrides），eg{'model': 'yolov8n.yaml'}
        overrides = self.overrides.copy()
        # 如果kwargs中是否存在'cfg'配置文件，则使用传递的cfg配置文件的参数赋值给overrides
        if kwargs.get('cfg'):
            LOGGER.info(f"cfg file passed. Overriding default params with {kwargs['cfg']}.")
            overrides = yaml_load(check_yaml(kwargs['cfg']))
        # 更新overrides字典
        overrides.update(kwargs)
        # 将model设置为'train'
        overrides['mode'] = 'train'
        # 判断是否有data,必须提供数据集。
        if not overrides.get('data'):
            raise AttributeError("Dataset required but missing, i.e. pass 'data=coco128.yaml'")
        # 检查是否存在'resume'参数。（恢复某次训练继续训练）
        if overrides.get('resume'):
            overrides['resume'] = self.ckpt_path
        # 任务类型赋值给'self.task'。eg：detect
        self.task = overrides.get('task') or self.task
        # 没有传入自定义trainer则加载默认的训练器，eg:yolo.detect.DetectionTrainer
        trainer = trainer or self.smart_load('trainer')
        # 创建一个trainer训练器实例
        self.trainer = trainer(overrides=overrides, _callbacks=self.callbacks)
        # 不是恢复训练则构建trainer的模型
        if not overrides.get('resume'):  # manually set model only if not resuming
            self.trainer.model = self.trainer.get_model(weights=self.model if self.ckpt else None, cfg=self.model.yaml)
            self.model = self.trainer.model
        self.trainer.hub_session = self.session  # attach optional HUB session
        # 开始训练过程
        self.trainer.train()
        # 训练完成后更新模型及训练参数
        # Update model and cfg after training
        if RANK in (-1, 0):
            # 更新模型
            self.model, _ = attempt_load_one_weight(str(self.trainer.best))
            # 更新参数
            self.overrides = self.model.args
            # self.trainer.validator.metrics用于计算目标检测模型的精确度、召回率和平均精确度（mAP）等检测指标,如果metrics不存在，则返回None
            self.metrics = getattr(self.trainer.validator, 'metrics', None)  # TODO: no metrics returned by DDP

    def to(self, device):
        # 将模型放到指定的设备进行运算
        """
        Sends the model to the given device.

        Args:
            device (str): device
        """
        self._check_is_pytorch_model()
        self.model.to(device)

    def tune(self, *args, **kwargs):
        # 超参数调优,参考https://docs.ultralytics.com/guides/hyperparameter-tuning
        # 用法eg：在 COCO8 上使用 AdamW 优化器对 YOLOv8n 进行 30 个 epoch 的超参数调优，并跳过绘图、检查点和验证
        # model.tune(data='coco8.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)

        """
        Runs hyperparameter tuning using Ray Tune. See ultralytics.utils.tuner.run_ray_tune for Args.

        Returns:
            (dict): A dictionary containing the results of the hyperparameter search.

        Raises:
            ModuleNotFoundError: If Ray Tune is not installed.
        """
        self._check_is_pytorch_model()
        from ultralytics.utils.tuner import run_ray_tune
        return run_ray_tune(self, *args, **kwargs)

    @property
    def names(self):
        # 返回加载模型的类名。
        """Returns class names of the loaded model."""
        return self.model.names if hasattr(self.model, 'names') else None

    @property
    def device(self):
        """Returns device if PyTorch model."""
        return next(self.model.parameters()).device if isinstance(self.model, nn.Module) else None

    @property
    def transforms(self):
        """Returns transform of the loaded model."""
        return self.model.transforms if hasattr(self.model, 'transforms') else None

    def add_callback(self, event: str, func):
        """Add a callback."""
        self.callbacks[event].append(func)

    def clear_callback(self, event: str):
        """Clear all event callbacks."""
        self.callbacks[event] = []

    @staticmethod
    def _reset_ckpt_args(args):
        """Reset arguments when loading a PyTorch model."""
        include = {'imgsz', 'data', 'task', 'single_cls'}  # only remember these arguments when loading a PyTorch model
        return {k: v for k, v in args.items() if k in include}

    def _reset_callbacks(self):
        """Reset all registered callbacks."""
        for event in callbacks.default_callbacks.keys():
            self.callbacks[event] = [callbacks.default_callbacks[event][0]]

    def __getattr__(self, attr):
        """Raises error if object has no requested attribute."""
        name = self.__class__.__name__
        raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")

    def smart_load(self, key):
        """Load model/trainer/validator/predictor."""
        try:
            return self.task_map[self.task][key]
        except Exception as e:
            name = self.__class__.__name__
            mode = inspect.stack()[1][3]  # get the function name.
            raise NotImplementedError(
                emojis(f'WARNING ⚠️ `{name}` model does not support `{mode}` mode for `{self.task}` task yet.')) from e

    @property
    def task_map(self):
        """
        Map head to model, trainer, validator, and predictor classes.

        Returns:
            task_map (dict): The map of model task to mode classes.
        """
        raise NotImplementedError('Please provide task map for your model!')

除了训练所需的方法外，model类中包含了以下重要内容

1、predict。推理。用法：

model.predict(source="datasets/images/val",save=True,save_conf=True,save_txt=True,name='output')

参数可参考default.yaml文件中Prediction settings部分

2、track。目标追踪。用法：

model.track(source=".avi", show=True,  save=True)

3、 val。评估。用法：

metrics = model.val()

4、 benchmark。模型基准测试。用法：

benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0))

测试所有导出格式，最终运行结果会显示可以导出的模型类型，每个类型导出的文件大小，指标和推理时间。可以了解不同的导出格式在不同硬件上的表现。以便选择最佳性能的导出格式。

5、 export。导出模型。用法：

model.export(format="onnx",dynamic=Ture, opset=12)

相关参数：参考https://docs.ultralytics.com/modes/export/
format:导出的格式，(ONNX,TorchScript,TensorRT,PaddlePaddle,TF SavedModel,TF GraphDef,TF Lite等，)
imgsz:图像尺寸
keras:(False)使用Keras导出TF SavedModel。
optimize:(False) TorchScript：针对移动设备进行优化。
half:(False)半精度
int8:(False)int8数据量相对小，计算速度可以更快
dynamic:（False）支持动态输入的ONNX/TF/TensorRT
simplify:(False)简化onnx模型
opset:(None) 默认最新版
workspace:（4） TensorRT workspace size (GB)
nms:CoreML添加 NMS非极大值抑制。

7、tune。自动迭代优化超参数。用法：

model.tune(data='coco8.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)

eg：在 COCO8 上使用 AdamW 优化器对 YOLOv8n 进行 30 个 epoch 的超参数调优，并跳过绘图、检查点和验证。 

其他部分下次继续，欢迎交流指正 。