zh/modes/train/

[giscus[bot]]

zh/modes/train/

使用Ultralytics YOLO 训练YOLOv8 模型的分步指南，包括单 GPU 和多 GPU 训练示例

https://docs.ultralytics.com/zh/modes/train/?h=%E8%8B%B9%E6%9E%9C

[Xiaon-Junf]

[pderrenger]

您好！感谢您指出文档中的小错误，确实应该是针对苹果M1/M2芯片的注释，而不是2个GPU。我们会尽快更正这一点，以避免任何可能的混淆。再次感谢您的细心，帮助我们改进文档！🙌📝

[wangztao]

这个翻译太那啥了吧， train翻译成火车？

[pderrenger]

哈哈，确实，“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”，指的是在机器学习中对模型进行训练，以提高其准确性和效率。感谢您指出这个问题，我们会尽快修正翻译错误。如果您有任何其他建议或问题，欢迎随时告诉我们！🚀

[KK2107405729]

我想了解一下，AMD的7900XTX能进行调用训练吗？我发现在pytorch当中已经出现了ROCm5.7和ROCm6.0的支持

[pderrenger]

是的，AMD的7900XTX可以用于训练，只要你的环境支持ROCm5.7或ROCm6.0。PyTorch已经对这些版本提供了支持，所以你应该能够在7900XTX上进行模型训练。确保你的系统已经安装了合适的ROCm版本，并且PyTorch也是支持ROCm的版本。这里有一个简单的例子展示如何在PyTorch中检查GPU可用性：

import torch

if torch.cuda.is_available():
    print("ROCm/GPU is available")
    print(torch.cuda.get_device_name(0))
else:
    print("ROCm/GPU is not available")

如果你遇到任何问题，确保ROCm安装正确，并且PyTorch版本与之兼容。🙂

[songziang182]

谢谢你们开发了这么完善的 yolov8🙏，
我想问一下，这两种训练方式的区别
model = YOLO('yolov8n.pt')
model = YOLO('yolov8n.yaml').load('yolov8n.pt')
model.train(.........)

[pderrenger]

Hello there! 😊

The main difference between the two training methods you've mentioned:

1. model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away.

2. model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained .pt model. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.

Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.

Let me know if this helps or if you have more questions!

[songziang182]

Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?

[pderrenger]

Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!

Regarding the yolov8n.yaml configuration file, it's essentially used to define the architecture for YOLOv8 models. This file allows you to adjust the model scale (e.g., n, s, m, l). If you're looking to work with different scales of the model, such as YOLOv8n, YOLOv8s, YOLOv8m, or YOLOv8l, usually, separate .yaml files are used for each scale that define the specifics of the architecture like depth multiple and width multiple.

Here's a simplified example of how you might adjust the scale in a YAML:

# Example for a custom model definition, which you'd need to adjust based on YOLOv8's architecture.
depth_multiple: 0.33  # Model depth scale
width_multiple: 0.50  # Layer channel scale

However, for specific scales like YOLOv8n or YOLOv8s, you'd typically download or refer to the existing YAML files provided by Ultralytics, which are tuned for those particular model sizes. If you can't find the YAML file (it should be in the GitHub repo or mentioned in the docs), it could be due to how the models are packaged or managed in the latest version.

To create or modify a model scale, you'd adjust these parameters in the model's YAML file, reflecting how deep and wide the neural network should be. Then load this YAML and the pretrained weights as you mentioned:

model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt')
model.train(.........)

Make sure to check the Ultralytics GitHub repository or documentation for the latest information on configuration files and model scaling. Also, model scaling might require a solid understanding of the network architecture to make effective modifications.

I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊

[Bjyh22]

Hello, how can I retain the ability of the preprocessor model to recognize certain classes when training a new model ? For example, the new model still retains the old model, like yolov8n.pt, the ability to recognize a person

[pderrenger]

@Bjyh22 hello!

To retain the ability to recognize certain classes (like a person) when training a new model on top of an old model like yolov8n.pt, you can achieve this by fine-tuning the pre-trained model on your new dataset. Make sure your new dataset includes examples of the classes you want to retain along with the new classes you aim to recognize. This way, the model can maintain its previously learned knowledge and gain new insights concurrently. Here's how you can start fine-tuning in Python:

from ultralytics import YOLO

# Load the pre-trained model
model = YOLO('yolov8n.pt')

# Fine-tune the model on your custom dataset
results = model.train(data='your_custom_data.yaml', epochs=100, imgsz=640)

Ensure your_custom_data.yaml contains examples of both old and new classes. This method is beneficial to leverage learned features without starting the learning process from scratch. Happy training! 🚀

[rd-fhl]

您好，请问我在train时和val时使用多个数据集，类似如下的yaml文件应该怎么配置指定的labels路径呢？
path: /dataset/ # dataset root dir
train: [images1/train, images2/train] # train images (relative to 'path') 128 images
val: [images1/val, images2/val] # val images (relative to 'path') 128 images
test: [images1/test, images2/test] # test images (optional)

[pderrenger]

@rd-fhl 您好！👋 对于使用多个数据集进行训练和验证，在yaml文件中，您已经正确地指定了多个数据集的路径。接下来，为了指定labels路径，您可以在相同的yaml文件中，为每个数据集设置labels的子目录或具体路径。如果您的数据集标签就位于在train和val指定的目录下（通常这是标准做法），那么您可能不需要另外指定标签路径，因为程序会自动寻找这些目录下的标签文件。

示例配置可能看起来像这样（如果标签文件位于训练、验证图片文件的同级目录下）：

path: /dataset/  # dataset root dir
train: 
  - images1/train
  - images2/train
val: 
  - images1/val
  - images2/val
# Labels 通常位于同名目录下，不需要额外指定

如果您的标签文件位置有所不同，或者需要特别指定，您可以在数据加载代码处进行自定义处理或明确指出标签文件的路径，但请注意，这可能需要您修改数据加载部分的代码来适配您的文件目录结构。

希望这能帮到您！如果有其他问题或需要更具体的帮助，请随时再次提问。

[yaoshisa]

Hello！"Can YOLOv8 detect lane lines?"

[glenn-jocher]

Hello there! 😊

Currently, YOLOv8 does not specifically target lane detection as its primary use case since it's more focused on object detection, segmentation, and pose estimation. However, if lane lines could be defined as objects, YOLOv8 has the flexibility to detect them with the right training dataset. You would need a dataset labeled with lane lines and then train a custom YOLOv8 model on this dataset.

Here's a basic example of how you might start training your model for lane detection:

from ultralytics import YOLO

# Customize and load your model configuration and dataset for lane detection
model = YOLO('custom_lane_detection_model.yaml')

# Train the model on your dataset where 'lane_dataset.yaml' is your custom lane dataset
results = model.train(data='lane_dataset.yaml', epochs=100, imgsz=640)

Remember, success in detecting lane lines would heavily depend on the quality and quantity of your labeled dataset, focusing on lane lines.

Hope this helps! Let us know if you have any more questions.🚀

[ddz16]

您好，为什么我训练过程中保存的best.pt和last.pt模型文件（200MB）比官方提供的预训练模型yolov8m.pt（50MB）大很多？以及如果我希望用我训练出来的best.pt来进行预测，我也是直接model = YOLO('best.pt')就可以吗？期待您的回复。

[pderrenger]

您好！😊 感谢您的提问。

训练过程中生成的best.pt和last.pt模型文件尺寸较大的原因可能与模型结构和参数数量的不同有关。预训练模型yolov8m.pt可能采用了一些优化技术来减少模型大小，比如量化或者剪枝。另外，best.pt和last.pt包含了更多的训练信息，如优化器状态，这也会导致文件尺寸增加。

确实，您可以直接使用model = YOLO('best.pt')来加载您训练好的best.pt模型来进行预测。这是完全正确的用法。

简单示例如下：

from ultralytics import YOLO

# 加载你训练好的模型来进行预测
model = YOLO('best.pt')  # 加载模型
results = model('path/to/your/image.jpg')  # 对图片进行推理
results.show()  # 显示推理结果

希望这能解答您的疑问！如果还有其他问题，欢迎继续提问！🌟

[gaiya12138]

你好，请问在目标识别预测测试集的时候，只能预测图像的结果和坐标什么的吗。有没有什么能计算出像训练时候验证集的评价指标的东西来评价测试集。就是测试集的什么精确率召回率，怎么计算。希望解答，谢谢。

[glenn-jocher]

你好！😊 对于在测试集上评估模型性能，比如计算精确率和召回率等评价指标，你可以使用 val 模式。虽然这通常用于验证集，但你也可以通过指定不同的数据配置文件来将其用于测试集。这里有个简单的例子：

1. 首先，确保你的测试集配置文件（比如test.yaml）已经准备好，类似于训练时使用的coco128.yaml。
2. 然后，运行这样的命令来评估你的模型：

yolo detect val model=path/to/your_model.pt data=test.yaml

这会让模型在指定的测试集上运行，并为你提供诸如精度、召回率等指标。

希望这有助于你！如果还有进一步的问题，随时提问。

[Ameridru]

您好，当我用python -m torch.distributed.run --nproc_per_node x train.py来进行多GPU训练时，每块GPU得到的batch-size是batch-size/num_gpu还是完整的batch-size？之所以会产生这个疑问，是因为我发现当设置同样的batch-size时，4GPU训练的精度似乎并不如2GPU。

[glenn-jocher]

您好！👋

在使用 torch.distributed.run 进行多GPU训练时，每块GPU接收到的是整个batch-size除以num_gpu的结果。所以，如果您是在4个GPU上训练，而batch-size设置为64，那么每个GPU上处理的batch-size实际上是16。这可能解释了您观察到的在4xGPU上训练与2xGPU比较时精度下降的情况。

在多GPU训练中调整batch-size以获得最佳性能通常需要实验确定最佳配置。希望这能帮助您了解背后的机制！如果有任何进一步的问题，请随时提问。

[Ameridru]

即使多块GPU平分了一个batch的图片，但每个GPU计算的梯度在该batch的梯度更新时是会合并到一起的。当我设置batch-size为16，分别用4xGPU和2xGPU训练时，每个batch最终都会合并16张图片的梯度来进行参数更新，所以实现的参数更新效果应该是相似的，为什么会出现精度上的变化呢？

[glenn-jocher]

你好！🙂

实际上，即使在多GPU训练中，每个GPU处理的batch-size较小（即总batch-size/num_gpu），最终每个batch的梯度确实会合并在一起用于更新模型参数。这确保了不论使用多少GPU，对模型的更新效果应该是一致的。

精度差异可能源于其他因素，如不同GPU配置下的随机权重初始化、数据加载和增强的方式、以及可能的通信开销等。每种设置下的训练动态都有细微差别，这可能导致训练结果有所不同。💡

推荐检查两个实验间的所有可能变量，并确保除了GPU数量外，所有其他配置都保持一致。此外，更多的实验和超参数调试可能有助于理解这一现象并优化模型表现。希望这有助于解答疑惑！

[379061296]

model = YOLO('yolov8n.pt') # 加载预训练模型(推荐用于训练)
model.train(data='coco128.yaml', epochs=100, batch=-1, workers=8, imgsz=320, exist_ok=True) # 训练模型

官方文档描述
exist_ok False 如果为 True，则允许覆盖现有的项目/名称目录。这对迭代实验非常有用，无需手动清除之前的输出。

训练模型，第一次训练100轮，查看训练图型 results.png 正常，重新训练100轮，results.png 出现过拟合现象，
去掉exist_ok=True参数，不通过exist_ok覆盖现有的项目/名称目录
又训练了2个100轮，查看2个项目文件，
train
train2
results.png 没出现过拟合那个问题
经过验证，exist_ok=True参数存在问题。

[pderrenger]

感谢您的反馈和仔细的实验！🙌 看起来 exist_ok=True 似乎对您的训练周期有重要影响。该参数确实允许覆盖现有项目/名称目录，通常用于迭代实验而无需手动删除先前的输出。

如果在启用 exist_ok=True 后出现过拟合，那么一个可能的解释是，重新训练时，可能未从头开始学习，而是在先前模型基础上继续训练，导致模型对训练数据过度拟合。每次实验都确保从清洁状态开始是个好习惯，尤其是在进行准确性关键实验时。

为了避免这种情况，您可以尝试：

1. 每次训练前显式删除之前的输出文件和目录，以确保从头开始训练。
2. 使用不同的项目/名称目录进行每次训练，以隔离实验并保留所有历史记录。

希望这有助于提升您的YOLOv8训练流程！如果有其他问题或需要进一步解释，请随时告知。让我们共同为YOLO社区贡献力量！💪

[379061296]

model = YOLO('yolov8n.pt') # 加载预训练模型(推荐用于训练)
model.train(data='coco128.yaml', epochs=100, batch=-1, workers=8, imgsz=320, exist_ok=True) # 训练模型

官方文档描述
exist_ok False 如果为 True，则允许覆盖现有的项目/名称目录。这对迭代实验非常有用，无需手动清除之前的输出。

训练模型，第一次训练100轮，查看训练图型 results.png 正常，重新训练100轮，results.png 出现过拟合现象，
去掉exist_ok=True参数，不通过exist_ok覆盖现有的项目/名称目录
又训练了2个100轮，查看2个项目文件，
train
train2
results.png 没出现过拟合那个问题
经过验证，exist_ok=True参数存在问题。

[pderrenger]

感谢您分享您的发现和经验！关于 exist_ok=True 的问题，我们的确需要进一步调查来理解它对训练动态的具体影响。该参数的设计初衷是为了方便模型训练时的实验迭代，但您的案例指出了可能存在的问题。

确实，exist_ok=True 允许覆盖现有的训练结果目录，这在迭代实验时很方便，但它可能会引起一些混淆，特别是在评估模型性能如出现过拟合等问题时。您的观察提示我们，在使用此参数时需要格外小心，以确保对模型行为的准确理解。

请继续使用分离的项目目录来重复训练，并关注结果的变化。这种做法确实可以帮助更清晰地跟踪实验变动对结果的影响。

如果您有兴趣，也可以考虑对训练过程中的各种参数进行更深入的分析，以进一步理解问题所在。这可能涉及到更详细地比较不同训练运行的参数配置和结果。此外，对于过拟合情况，可能还需要考虑调整模型的正则化方法或数据增广策略。

再次感谢您对此问题的详细说明和反馈！如果在未来的实验中您有更多的发现或者有进一步的问题，欢迎您继续分享。🌟

[gcpctt]

您好，我想修改一下模型的损失函数，因为我的数据集涉及到数据不均衡问题，所以想使用focal loss，我该在哪里修改呢？

[glenn-jocher]

@gcpctt 嗨，感谢你的问题！😊

要在YOLOv8中使用focal loss处理数据不均衡问题，你需要对源代码进行一些编辑。具体操作如下：

1. 找到损失函数定义的地方。对于YOLOv8，损失函数通常在模型定义文件中定义。这个文件可能是models/yolo.py或者一个与你使用的模型结构相关的文件。

2. 定位到损失函数的实现部分。例如，YOLO损失可能在ComputeLoss类中。

3. 在这个类中，你可以根据需要替换现有的损失函数为focal loss。如果已经有实现focal loss的代码，只需调整参数即可。否则，你可能需要自己实现focal loss的公式。

下面是一个focal loss示例代码片段:

class FocalLoss(nn.Module):
    def __init__(self, alpha=0.25, gamma=2.0):
        super(FocalLoss, self).__init__()
        self.alpha = alpha
        self.gamma = gamma

    def forward(self, inputs, targets):
        BCE_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction='none')
        pt = torch.exp(-BCE_loss)
        F_loss = self.alpha * (1-pt)**self.gamma * BCE_loss
        return F_loss.mean()

然后，你需要在ComputeLoss类或相应位置使用你的FocalLoss类。

请注意，对代码的任何修改都必须在深入理解YOLOv8代码结构的基础上进行。建议先在小型数据集上验证更改的效果。希望这能帮助到你！如果有任何问题，请随时提问。

[yaoshisa]

How to freeze weights for other classes and train weights for new classes only on the training set.

[pderrenger]

Hey there 👋!

To selectively train new classes while freezing the weights of other classes, you can utilize the "freeze" argument in your training command or within your Python code. This argument allows you to specify layers of the model that should not be updated during training. Here's how you can do it:

Using CLI

To freeze layers except for the last few (e.g., training only the classifier for new classes), you might use:

yolo train data=new_data.yaml model=yolov8n.pt freeze=15

This command freezes the first 15 layers of the model during training, allowing only the subsequent layers to update. Change 15 to the appropriate number based on the model architecture and your specific needs.

Using Python API

Similarly, in Python, you would specify:

from ultralytics import YOLO

# Load model
model = YOLO('yolov8n.pt')

# Train with specific layers frozen
results = model.train(data='new_data.yaml', epochs=100, imgsz=640, freeze=15)

This snippet achieves the same by freezing the first 15 layers of the YOLOv8 model during training on the new dataset defined in new_data.yaml.

Make sure to adjust the freeze parameter according to your model’s structure and the layers you intend to freeze. Happy training! 😊

[yaoshisa]

How can you use yolov8 to train only on new class data sets to achieve incremental learning without forgetting previous detection capabilities。

[pderrenger]

To achieve incremental learning with YOLOv8 where you add new class datasets without forgetting previous capabilities, you can employ a technique known as fine-tuning. This involves loading a pre-trained model and continuing the training process on your new dataset. Here's how you can do it in a concise way:

from ultralytics import YOLO

# Load your pre-trained model
model = YOLO('path/to/your/pretrained/model.pt')

# Continue training on the new dataset
results = model.train(data='path/to/your/new/class/dataset.yaml', epochs=100, imgsz=640)

Make sure your dataset is properly annotated and formatted. This method allows the model to retain its previously learned detection capabilities while adapting to the new classes in your dataset. Keep an eye on the training process to ensure it's progressing well! 🚀

[bixi2656]

您好，我想让一个数据集被多个模型训练，但是数据集被模型读取后会在datasets文件下生成labels.cache文件，而该文件无法被其他模型使用，所以请问有没有修改方法能够使得模型读取数据集后不生成labels.cache文件，或者能够使一个数据集文件被多个模型同时训练使用呢？万分感谢！Thank you！

[glenn-jocher]

您好！感谢您的提问。😊

确实，当您训练多个模型时，.cache 文件可能会造成一些不便。不过，有一个简单的解决方案：您可以在运行训练命令时，通过在训练命令中增加一个 cache=False 参数来阻止生成 labels.cache 文件。例如：

yolo train data=your_dataset.yaml model=yolov8n.pt cache=False

如果您希望一个数据集被多个模型同时训练使用，确保为每个模型训练创建不同的数据集配置文件 (yaml) 并在其中使用不同的缓存文件名，或者直接关闭缓存功能。

希望这个方法能帮到您！如果有其他问题或需要更多帮助，随时留言。👍

[pderrenger]

您好！感谢您的提问。😊

确实，当您训练多个模型且它们同时读取相同的数据集时，labels.cache 文件确实可能成为一个问题。不过，解决方法很简单！

首先，您可以在数据集的 YAML 文件中为每个模型指定不同的路径，这样每个模型都会在自己的路径下生成自己的 cache 文件。

另一种方法是通过 Python 脚本或命令行接口 (CLI) 使用不同的 cache 参数值运行训练。例如，在 Python 中，可以这样做：

from ultralytics import YOLO

model = YOLO('path/to/model.yaml')
results = model.train(data='path/to/data.yaml', cache=False)

或者在命令行中：

yolo train model=path/to/model.yaml data=path/to/data.yaml cache=False

这样做，您可以在不生成 labels.cache 文件的情况下训练您的模型，或者确保每个模型使用不同的 cache 文件，从而避免潜在的冲突。

希望这能帮助到您！如果还有其他问题，欢迎继续提问。🚀

[bixi2656]

我使用了第二个方法，我的命令为epochs=300 ,imgsz=640, workers=64, batch=32, patience=300, cache=False。但是仍会在datasets文件夹下生成labels.cache文件。具体提示为New cache created: datasets/labels.cache，当我使用第二个模型调用该数据集时，会提示图片不在该路径下，请问我应该如何解决呢？非常感谢你们的回答！Thank you！

[pderrenger]

您好！看起来即便在命令中添加了 cache=False，模型训练过程还是会生成 labels.cache 文件。这是因为在 Ultralytics YOLO 的实现中，可能即使禁用缓存，一些内部机制仍然需要创建这个文件以提高训练效率。对于您提到的路径问题，可以尝试以下解决方法：

1. 确保数据路径正确：请仔细检查在您的数据集配置文件 (*.yaml) 中指定的图像和标注文件路径是否完全正确，包括每个图像文件的路径。

2. 删除旧的 cache 文件：在重新运行训练之前，尝试手动删除任何存在的 labels.cache 文件，以避免可能的路径不匹配问题。

3. 使用绝对路径：在数据集配置文件中使用绝对路径而非相对路径，这样可以减少因路径解析错误导致的问题。

这里是一个数据集配置文件的示例，显示如何指定绝对路径：

train: /absolute/path/to/your/train/images
val: /absolute/path/to/your/val/images

nc: 20  # 类别数
names: ['class1', 'class2', ...]  # 类别名称

如果您尝试过上面的方法仍然无法解决这个问题，那么也许可以考虑将每个模型的训练数据放在不同的文件夹内，并为每个模型指定不同的数据集配置文件，这样它们不会相互干扰。

希望这些建议能够帮助到您！如果还有其他问题，欢迎继续询问。👍

[Ameridru]

我想用一个python脚本连续训练两个模型，但发现训练完第一个模型后就会出错，请问应该怎么训练多个模型？

[pderrenger]

您好！训练多个模型的一个有效方法是确保每次训练完成后清理并重置 CUDA 缓存。这样可以防止第一个模型训练的状态干扰到后续模型的训练。以下是一个简单的示例，展示如何在 Python 脚本中依次训练两个模型：

from ultralytics import YOLO
import torch

# 定义要训练的模型和数据集
models_datasets = [
    ('yolov8n.yaml', 'dataset1.yaml'),
    ('yolov8n.yaml', 'dataset2.yaml')
]

for model_config, dataset_config in models_datasets:
    # 加载模型
    model = YOLO(model_config)

    # 训练模型
    model.train(data=dataset_config, epochs=100, imgsz=640)

    # 训练完成后清理 CUDA 缓存
    torch.cuda.empty_cache()

这里我们使用 torch.cuda.empty_cache() 来清理 CUDA 缓存，从而为接下来的模型训练释放内存。希望这能帮助到您！如果有进一步的问题，欢迎继续提问。🙂

[glenn-jocher]

您好！如果您想要在一个Python脚本中连续训练两个模型，可能需要确保在训练第一个模型结束后正确地释放GPU资源，再开始第二个模型的训练。一个简单的方法是为每个模型的训练过程写一个单独的脚本，并在主脚本中依次调用这些脚本，比如使用Python的subprocess模块。这是个示例：

import subprocess

# 训练第一个模型
subprocess.run(['python', 'train_first_model.py'])

# 训练第二个模型
subprocess.run(['python', 'train_second_model.py'])

确保每个训练脚本train_first_model.py和train_second_model.py都包含了相应模型的训练代码逻辑，且在每次训练结束后都有适当的清理和资源释放步骤。希望这个方法能帮助到您！😊

[Ameridru]

请问在模型训练时，如何不使用albumentation库进行数据增广？在yaml配置文件中没有albumentation相关选项

[glenn-jocher]

嗨，感谢您的提问！😊

如果您想在模型训练时避免使用albumentation进行数据增广，不需要在yaml配置文件中指定任何关于albumentation的选项。YOLOv8在默认情况下不强制使用albumentation库。

要控制数据增广，您可以调整YAML中的增广配置，例如修改hsv_h, hsv_s, hsv_v, translate, scale, flipud, fliplr等设置。这些设置对YOLOv8的内置数据增广机制进行了控制。

例如，如果要最小化数据增广，可以在YAML中设置所有这些参数为0或将它们调整到最低强度。这里是一个如何调整的简单例子：

# 在你的数据集yaml文件内
hsv_h: 0  # 色调
hsv_s: 0  # 饱和度
hsv_v: 0  # 亮度
translate: 0  # 平移
scale: 0  # 缩放
flipud: 0  # 上下翻转
fliplr: 0  # 左右翻转

请注意，一定程度的数据增广有助于提高模型的泛化能力，完全禁用可能降低模型性能。

希望这有助于您的训练！如果还有其他问题，请随时问。👍

[Ameridru]

但是我在没有进行任何albumentation库相关设置的情况下，训练模型会打印以下信息：albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))。这是什么原因呢？

[glenn-jocher]

嗨！👋 如果您在训练期间看到 albumentation 相关的信息打印出来，但您并没有在配置文件中明确设置它，这可能是因为 Ultralytics YOLOv8 在其训练过程中默认采用了一些基本的 albumentation 数据增广。

即便您没有在 YAML 文件中明确启用 albumentations，YOLOv8 的训练代码可能还是会默认使用一些预设增广方法来优化模型的学习过程。这些默认设置的目的是帮助模型更好地泛化和适应不同的数据变化。

如果您想禁用这些默认增广，或对增广进行更细致的控制，您可以通过修改训练脚本中相关的代码段来实现。当前，YAML配置文件不直接支持开启或关闭 albumentations 的选项。一种可能的方法是，检查模型或数据加载部分的代码，看是否有默认启用的数据增广设置，并根据需要进行调整。

希望这有助于澄清！如果还有其他问题或需要进一步的帮助，请随时提问。

[super-song-sir]

Hi I'm new to this and I was wondering how the .yaml file should be configured to train its own dataset. I didn't find a tutorial about it on our webpage.

[pderrenger]

@super-song-sir hey there! 😊 Welcome to the Ultralytics YOLOv8 community. Configuring your .yaml file for training on your own dataset is quite straightforward. The key is to specify your dataset's details, including paths to your train and validation sets, class names, and the number of classes. Here's a basic template to help you get started:

# dataset.yaml
train: /path/to/your/train/images 
val: /path/to/your/val/images 

# Classes
nc: 10  # number of classes
names: ['class1', 'class2', 'class3', ..., 'class10']

• train and val are the directories containing your training and validation image files, respectively.
• nc is the number of unique classes in your dataset.
• names is a list of class names as strings.

To train with this dataset, simply pass your .yaml file to the train command:

yolo detect train data=dataset.yaml model=yolov8n.pt

Ensure that your images and corresponding annotations are correctly formatted. We recommend checking out our documentation on custom dataset training for a detailed guide.

If you need more help, feel free to ask! 🚀

[super-song-sir]

Thank you for your reply. I have solved this problem. But I get a new problem，when I train my own datasets. I find train datasets‘progress bar is 100%|██████████| 58/58 . This is true because my train datasets is 928 while batchsize is 16 .But the val dataset's progress bar is 100%|██████████| 8/8 while my val datasets is 232. This is not true. I only run "results = model.train(data='D:/project/ultralytics-main/data_yaml/ssdd.yaml', epochs=30, imgsz=640)". Could you tell me why ?

[super-song-sir]

But when I only run val code,it shows 100%|██████████| 15/15，Is this because we randomly selected some photos from the validation set when we performed the validation during training? Or is it some other reason? I didn't find the validation set batch size for validation at training time. Sorry to bother you.

[pderrenger]

Hey there! No worries about the questions – it's great to see your engagement and curiosity. 😊 Let's clarify the validation batch situation.

During training, validation is indeed performed on a subset of the complete validation dataset, not the entire set. This approach serves to quickly assess the model's performance without significantly slowing down the training process. The smaller batch size for validation (i.e., 8 batches) you're observing, compared to what might be expected from the full validation dataset size (e.g., 15 batches for 232 images), points to this subset evaluation method.

The number of batches processed during validation is determined by the val batch size and the total number of images in your validation dataset. If you're seeing a discrepancy in the number of validation batches during standalone validation vs. during training validation, it's likely due to differences in how validation is configured or executed in these two scenarios.

Remember, the primary goal during training is to learn and adapt based on the training dataset, with validation serving as a quick check to prevent overfitting and to monitor generalization to unseen data.

Hope this helps clear things up! If you have any more questions, feel free to ask. Happy training! 🚀

[cnlk-njyx]

请问YOLOv8模型如何保留其对人的识别能力，并在其基础上添加其他（自己训练其他类别）的目标检测？

[Xiaon-Junf]

YOLO的模型原本就是支持识别人的，你只需要自己制作训练集训练识别其他物体即可，注意训练时的yaml文件应该除了你自己要识别的物体之外还要添加person，具体的话就是：

nc: 类别数
names: 
    0: person 
    1: ...(你自己想要识别的东西)

至于训练集要不要包含对人的框选，看你们的项目需求，一般来说yolov8n的识别能力已经不错了，就省的再麻烦去人工框选了

[Xiaon-Junf]

你也可以参考官方的文章，看看yolov8能够识别什么东西，比如COCO数据集中的东西yolo都是能够识别的

[glenn-jocher]

To preserve the detection ability for person while adding additional custom categories in YOLOv8, you can update your dataset and model configuration as follows:

1. Update Dataset: Ensure your dataset includes images with person annotations and those of your new categories. This helps the model continue learning to recognize people and learn new objects simultaneously.

2. Modify YAML Configuration: In your data.yaml file, retain the person class and add new classes. Your YAML might look something like this:

   names:
     - person
     - new_category1
     - new_category2

3. Train with Combined Classes: When training, use the updated YAML configuration. This setup teaches the model both old and new object classes.

4. Training Command:
   Consider using the following command if training with Ultralytics YOLO interface:

   yolo detect train data=your_dataset.yaml model=yolov8.pt

This approach ensures your YOLOv8 model retains its effectiveness in detecting people and becomes capable of recognizing new objects defined in your dataset. Adjust the hyperparameters and training settings in the YAML files as needed to optimize for your specific use case.

[yueguang01]

为什么我使用自己训练好的权重去训练会报错？RuntimeError:
An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.

    This probably means that you are not using fork to start your
    child processes and you have forgotten to use the proper idiom
    in the main module:

        if __name__ == '__main__':
            freeze_support()
            ...

    The "freeze_support()" line can be omitted if the program
    is not going to be frozen to produce an executable.

[pderrenger]

It looks like you're encountering a multiprocessing issue common in Python, especially when using data loaders in a Windows environment. To resolve this, you can wrap your training code under the if __name__ == '__main__': guard to ensure that your training script behaves as expected when using multiprocessing. Here’s how you can modify your script:

from ultralytics import YOLO

def train():
    # Load a model
    model = YOLO("yolov8n.yaml").load("yolov8n.pt")  # build from YAML and transfer weights

    # Train the model
    results = model.train(data="coco128.yaml", epochs=100, imgsz=640)

if __name__ == '__main__':
    train()

This change ensures that the training process starts only if the script is run as the main program. This structure is particularly important in Windows, where the Python multiprocessing module requires if __name__ == '__main__': to start processes safely. If you continue to experience issues, please ensure that all your packages are up-to-date and consider running your script in environments like Linux where multiprocessing behaves differently.

[xxh-zcl]

您好，看到这个教程中可以利用setting来修改预设的参数，尝试了一下并没有生效还是会输出默认的参数，请问一下现在的yolov10-main代码库能用setting来修改预设参数吗？具体代码如下：
from ultralytics import settings
settings.update({'datasets_dir': data_yaml_path,
'weights_dir': pre_model_name,
"runs_dir": runs,
})
settings.reset()
print(settings)

[pderrenger]

@xxh-zcl 您好，

感谢您的提问！在当前的YOLOv10代码库中，settings模块确实可以用来修改预设参数。不过，您需要确保在更新设置后调用settings.save()来保存更改，而不是settings.reset()，因为reset()会重置所有设置为默认值。

请尝试以下代码：

from ultralytics import settings

settings.update({
    'datasets_dir': data_yaml_path,
    'weights_dir': pre_model_name,
    'runs_dir': runs,
})
settings.save()
print(settings)

这样应该可以正确地应用您的自定义设置。如果还有其他问题，请随时告知！😊

祝您好运！

[akai-takumi]

Why do I always get an error when using the GhostConv module from the source code File "D:\ultralyticsain-multralytics\n\modules\block.py", line 698, in init
self.ghost_cbs1 = GHOSTCBS(c1, c2, kernel_size=1, stride=1)
File "D:\ultralytics-main\ultralytics\nn\modules\block.py", line 799, in init
self.conv = nn.GhostConv(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
AttributeError: module 'torch.nn' has no attribute 'GhostConv' (attribute error)

[pderrenger]

@akai-takumi hello!

Thank you for reaching out and providing details about the issue you're encountering with the GhostConv module. Let's work through this together.

Steps to Resolve the Issue:

1. Verify the Code Example:
   To assist you better, could you please provide a minimum reproducible code example? This will help us understand the context and reproduce the issue on our end. You can follow the guidelines here: Minimum Reproducible Example.

2. Check Package Versions:
   Ensure you are using the latest versions of both torch and ultralytics. Sometimes, issues arise due to outdated packages. You can update them using the following commands:

   pip install --upgrade torch ultralytics

3. GhostConv Module:
   The error message indicates that torch.nn does not have an attribute GhostConv. This suggests that GhostConv might not be a standard module in PyTorch. If GhostConv is a custom module, ensure it is properly defined and imported in your code.

Example Code to Load and Train a Model:

Here’s a quick example to ensure your environment is set up correctly:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load a pretrained model

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Multi-GPU Training:

If you are using multiple GPUs, you can specify the devices as follows:

results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

Apple M1 and M2 MPS Training:

For Apple M1 and M2 chips, you can specify the device as mps:

results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Resuming Interrupted Training:

To resume training from a checkpoint:

results = model.train(resume=True)

Please try these steps and let us know if the issue persists. Providing the minimum reproducible example will greatly help us in diagnosing the problem more effectively.

Looking forward to your response!

[akai-takumi]

Thank you for your reply, the GhostConv module is defined in the source code at ultralytics/nn/modules/conv.py and is already written in your project, I defined my own module called GHOSTCBS to call the GhostConv module, but the program produces the following at runtime AttributeError. I have updated torch ultralytics but still get the same error.
My test example is as follows

project/
|-- nn/
|   |-- modules/
|       |-- conv.py  # GhostConv is defined here

        class GhostConv(nn.Module):
    """Ghost Convolution https://github.com/huawei-noah/ghostnet."""

    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        """Initializes the GhostConv object with input channels, output channels, kernel size, stride, groups and
        activation.
        """
        super().__init__()
        c_ = c2 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, k, s, None, g, act=act)
        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)

    def forward(self, x):
        """Forward propagation through a Ghost Bottleneck layer with skip connection."""
        y = self.cv1(x)
        return torch.cat((y, self.cv2(y)), 1)

|       |-- block.py  # GHOSTCBS is defined here
        from .conv import  GhostConv,
        class GHOSTCBS(nn.Module):
        def __init__(self, in_channels, out_channels, kernel_size, stride):
            super(GHOSTCBS, self).__init__()
            self.conv = nn.GhostConv(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
            self.bn = nn.BatchNorm2d(out_channels)
            self.silu = nn.SiLU()

        def forward(self, x):
            return self.silu(self.bn(self.conv(x)))
|-- test.py
|

 test.py
# main.py
from ultralytics.nn.modules.block import GHOSTCBS
import torch

# bulid GhostCBS layer
cbs_layer = GHOSTCBS(in_channels=3, out_channels=16, kernel_size=3,stride=1)

# use GhostCBS layer
input_tensor = torch.randn(1, 3, 224, 224)
output_tensor = cbs_layer(input_tensor)
print(output_tensor.shape)

and the test.py got an error :AttributeError: module 'torch.nn' has no attribute 'GhostConv'

[pderrenger]

Hello @akai-takumi,

Thank you for providing the detailed information and code snippets. It helps a lot in understanding the issue you're facing with the GhostConv module.

Issue Analysis

The error AttributeError: module 'torch.nn' has no attribute 'GhostConv' suggests that the GhostConv class is not being recognized as part of the torch.nn module. This is because GhostConv is a custom module defined in your project, not a built-in PyTorch module.

Solution

To resolve this, you need to ensure that your custom module is correctly imported and used. Here's how you can modify your GHOSTCBS class to use the GhostConv module from your conv.py file:

1. Correct Import Statement: Ensure you import GhostConv correctly in your block.py file.
2. Use the Correct Namespace: Since GhostConv is not part of torch.nn, you should use it directly from your custom module.

Updated Code Example

Here’s how you can adjust your code:

conv.py:

import torch
import torch.nn as nn

class GhostConv(nn.Module):
    """Ghost Convolution https://github.com/huawei-noah/ghostnet."""

    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        """Initializes the GhostConv object with input channels, output channels, kernel size, stride, groups and
        activation.
        """
        super().__init__()
        c_ = c2 // 2  # hidden channels
        self.cv1 = nn.Conv2d(c1, c_, k, s, groups=g, bias=False)
        self.cv2 = nn.Conv2d(c_, c_, 5, 1, groups=c_, bias=False)

    def forward(self, x):
        """Forward propagation through a Ghost Bottleneck layer with skip connection."""
        y = self.cv1(x)
        return torch.cat((y, self.cv2(y)), 1)

block.py:

import torch
import torch.nn as nn
from .conv import GhostConv  # Correctly import GhostConv

class GHOSTCBS(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride):
        super(GHOSTCBS, self).__init__()
        self.conv = GhostConv(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
        self.bn = nn.BatchNorm2d(out_channels)
        self.silu = nn.SiLU()

    def forward(self, x):
        return self.silu(self.bn(self.conv(x)))

test.py:

from ultralytics.nn.modules.block import GHOSTCBS
import torch

# Build GhostCBS layer
cbs_layer = GHOSTCBS(in_channels=3, out_channels=16, kernel_size=3, stride=1)

# Use GhostCBS layer
input_tensor = torch.randn(1, 3, 224, 224)
output_tensor = cbs_layer(input_tensor)
print(output_tensor.shape)

Additional Tips

• Ensure that your project structure is correctly set up and that Python can find the modules. You might need to adjust your PYTHONPATH or use relative imports.
• Verify that you are using the latest versions of torch and ultralytics to avoid any compatibility issues.

If you continue to experience issues, please provide any additional error messages or logs. This will help us further diagnose and resolve the problem.

Feel free to reach out if you have any more questions or need further assistance. 😊

[akai-takumi]

Thank you very much for your reply, I have figured out what was wrong and fixed the problem, thanks again!

[pderrenger]

Hello @akai-takumi,

Thank you for the update! I'm glad to hear that you were able to identify and resolve the issue. If you have any more questions or run into any other challenges, feel free to reach out. The YOLO community and the Ultralytics team are always here to help.

Happy coding and best of luck with your projects! 😊

[NoviceAlchemist]

您好，我想问两个问题：
第一个问题是：我训练模型初始化YOLOV8模型指定的路径是YOLOV8.yaml文件，但是会自动下载一个YOLOV8n的权重pt文件，这个要怎么修改才可解决不自动下载pt文件，我设置了pretrained=False还是会自动下载。
第二个问题是：我训练出来的YOLOV8模型想最终转换为RKNN模型部署，我将pt文件通过官方代码转换为onnx但是输出不符合RKNN标准，然后在git上面找到了修改后老版本的ultrlytics它支持转完成RKNN支持的onnx，但是我将其修改部分在新版ultrlytics中进行相对应的修改发现无法运行，如果我是用修改后老版本的ultrlytics他会训练的时候初始化两次，您这边是否更新了新版的ultrlytics支持转换RKNN的onnx？

[glenn-jocher]

@hpz98 您好，感谢您的提问！

关于第一个问题：

为了防止YOLOv8模型在初始化时自动下载预训练权重文件（.pt），您可以尝试以下方法：

1. 确保pretrained=False：您已经尝试过这一点，但请确保在代码中正确设置了此参数。
2. 手动指定权重路径：如果您不希望使用任何预训练权重，可以尝试手动指定一个不存在的路径或空路径。

示例代码：

from ultralytics import YOLO

# Load a model without downloading pretrained weights
model = YOLO("yolov8n.yaml", pretrained=False)

关于第二个问题：

将YOLOv8模型转换为RKNN模型确实需要一些特定的步骤。以下是一些建议：

1. 确保使用最新版本：请确认您使用的是Ultralytics和相关库的最新版本，因为新版本可能包含对RKNN转换的改进。
2. 检查ONNX模型的兼容性：RKNN对ONNX模型有特定的要求，您可能需要对ONNX模型进行一些调整以确保兼容性。

如果您遇到转换问题，可以尝试以下步骤：

• 使用最新的Ultralytics版本：确保您使用的是最新版本的Ultralytics库。
• 调整ONNX模型：根据RKNN的要求，调整ONNX模型的结构和参数。

示例代码（转换为ONNX）：

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolov8n.pt")

# Export the model to ONNX format
model.export(format="onnx", simplify=True)

如果问题仍然存在，建议提供一个最小可复现的示例代码，以便我们更好地帮助您解决问题。您可以参考最小可复现示例的文档。

希望这些信息对您有所帮助！如果有进一步的问题，请随时告知 😊

祝好，
Ultralytics 团队

[NoviceAlchemist]

第一个问题的解决方法：我写的是：model_path = r'D:\csyk-py\ultralytics-main\ultralytics\cfg\models\v8\yolov8.yaml'
model = YOLO(model_path,pretrained=False)，但是会出现T：ypeError: init() got an unexpected keyword argument 'pretrained'。
第二个的话：我写的是：from ultralytics import YOLO

Load a model

model = YOLO(r'D:\ultralytics-main\model train\model\yolov8m.pt') # load an official model

model = YOLO('path/to/best.pt') # load a custom trained

input_width, input_height = 640, 640 # set the input size

Export the model

model.export(format='onnx',imgsz=[input_width,input_height],opset=12,int8=True,simplify=True)
但是会出现：Traceback (most recent call last):
File "D:\ultralytics-main\model train\Test\yolo to onnx.py", line 67, in
model.export(format='onnx',imgsz=[input_width,input_height],opset=12,int8=True,simplify=True)
File "D:\ultralytics-main\ultralytics\engine\model.py", line 606, in export
from .exporter import Exporter
File "D:\ultralytics-main\ultralytics\engine\exporter.py", line 74, in
from ultralytics.utils import (
ImportError: cannot import name 'IS_JETSON' from 'ultralytics.utils' (D:\ultralytics-main\ultralytics\utils_init_.py)
可以转换的文件地址是：https://github.com/airockchip/ultralytics_yolov8
这个里面修改了部分文件而且集成文件和最新版的文件不一样，他会初始化模型两遍

[glenn-jocher]

您好，谢谢您的详细反馈！

关于第一个问题：

您遇到的TypeError: __init__() got an unexpected keyword argument 'pretrained'错误是因为YOLO类的初始化方法不接受pretrained参数。要解决这个问题，您可以先加载模型配置文件，然后再手动加载权重。

以下是修改后的代码示例：

from ultralytics import YOLO

# Load a model from YAML without pretrained weights
model = YOLO("D:/csyk-py/ultralytics-main/ultralytics/cfg/models/v8/yolov8.yaml")

# Optionally, you can load weights manually if needed
# model.load_weights("path/to/weights.pt")

关于第二个问题：

您在将YOLOv8模型转换为ONNX格式时遇到的问题可能与导入路径或依赖项有关。请确保您使用的是最新版本的Ultralytics库，并且所有依赖项都已正确安装。

以下是转换为ONNX格式的代码示例：

from ultralytics import YOLO

# Load a model
model = YOLO("D:/ultralytics-main/model train/model/yolov8m.pt")

# Set the input size
input_width, input_height = 640, 640

# Export the model to ONNX format
model.export(format='onnx', imgsz=[input_width, input_height], opset=12, simplify=True)

如果您仍然遇到ImportError: cannot import name 'IS_JETSON' from 'ultralytics.utils'错误，建议您检查以下几点：

1. 确保使用最新版本的Ultralytics库：可以通过pip install --upgrade ultralytics来更新。
2. 清理和重新安装依赖项：有时依赖项可能会出现冲突，建议您清理并重新安装所有依赖项。

如果问题依旧存在，请提供一个最小可复现的示例代码，以便我们更好地帮助您解决问题。您可以参考最小可复现示例的文档。

希望这些信息对您有所帮助！如果有进一步的问题，请随时告知 😊

祝好，
Ultralytics 团队

[NoviceAlchemist]

是这样的第二个问题下面有一个链接，里面是修改后的onnx转换所需要的文件，然后好像也是ultralytics的，您这边可以看一下，因为这个文件版本是旧版本，新版本不支持这样修改，您这边后续是否有时间更新一个新的版本？然后您给我知道还是会出现equiv_channels(8400>1imitations(8192)

[glenn-jocher]

@hpz98 您好，感谢您提供详细的信息和链接。

关于第一个问题：

为了防止YOLOv8模型在初始化时自动下载预训练权重文件（.pt），您可以尝试以下方法：

1. 确保正确加载模型配置文件：请确认您正确加载了模型配置文件，并且没有指定预训练权重。
2. 手动加载模型配置：您可以手动加载模型配置文件，并确保不使用预训练权重。

以下是修改后的代码示例：

from ultralytics import YOLO

# Load a model from YAML without pretrained weights
model = YOLO("D:/csyk-py/ultralytics-main/ultralytics/cfg/models/v8/yolov8.yaml")

# Optionally, you can load weights manually if needed
# model.load_weights("path/to/weights.pt")

关于第二个问题：

您在将YOLOv8模型转换为ONNX格式时遇到的问题可能与导入路径或依赖项有关。请确保您使用的是最新版本的Ultralytics库，并且所有依赖项都已正确安装。

以下是转换为ONNX格式的代码示例：

from ultralytics import YOLO

# Load a model
model = YOLO("D:/ultralytics-main/model train/model/yolov8m.pt")

# Set the input size
input_width, input_height = 640, 640

# Export the model to ONNX format
model.export(format='onnx', imgsz=[input_width, input_height], opset=12, simplify=True)

如果您仍然遇到ImportError: cannot import name 'IS_JETSON' from 'ultralytics.utils'错误，建议您检查以下几点：

1. 确保使用最新版本的Ultralytics库：可以通过pip install --upgrade ultralytics来更新。
2. 清理和重新安装依赖项：有时依赖项可能会出现冲突，建议您清理并重新安装所有依赖项。

关于您提到的equiv_channels(8400>1imitations(8192)错误，这可能是由于ONNX模型的某些层或参数超出了RKNN的限制。建议您参考RKNN的文档，确保ONNX模型符合其要求。

如果问题依旧存在，请提供一个最小可复现的示例代码，以便我们更好地帮助您解决问题。您可以参考最小可复现示例的文档。

希望这些信息对您有所帮助！如果有进一步的问题，请随时告知 😊

祝好，
Ultralytics 团队

[TZDXF]

您好，我想在原来17个关键点的基础上，增加新的关键点识别，我在原来的数据集上增加了新的关键点，训练的时候应该怎么去训练，可以保留原来的17个关键点的识别，并且有支持新增关键点识别呢

[glenn-jocher]

@TZDXF 您好！

要在现有的17个关键点基础上增加新的关键点识别，并保留原有的关键点，您可以按照以下步骤进行训练：

1. 更新数据集：确保您的数据集包含所有新的关键点标注，并且标注文件格式正确。

2. 修改配置文件：更新数据集配置文件（如coco.yaml）中的nc（类别数）和names（类别名称）字段，以包含新的关键点。

3. 训练模型：

   • 如果您已经有一个预训练模型，可以在其基础上进行微调，这样可以保留原有的17个关键点识别能力，同时增加新的关键点识别。
   • 使用以下代码进行训练：

from ultralytics import YOLO

# 加载预训练模型
model = YOLO("yolov8n.pt")

# 训练模型
results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)

或者使用命令行：

# 从预训练模型开始训练
yolo detect train data=path/to/your_dataset.yaml model=yolov8n.pt epochs=100 imgsz=640

4. 验证和调整：在训练过程中，监控模型的性能。如果需要，可以调整超参数（如学习率、批量大小等）以获得更好的结果。

如果您遇到任何问题或需要进一步的帮助，请提供一个最小可复现的示例代码，这将帮助我们更好地理解和解决您的问题。您可以参考最小可复现示例来创建这个示例。

另外，请确保您使用的是最新版本的Ultralytics YOLO，以避免已修复的已知问题。

希望这些信息对您有所帮助！如果有其他问题，请随时告知 😊

祝您训练顺利！

Ultralytics 团队

[Stephen-Hao]

您好：
我通过YAML文件自定义了一个网络结构：yolov8s_custom。对于下游任务，我想加载预训练的COCO模型yolov8s.pt。使用脚本1，我可以加载预训练的参数，并在下游任务上成功实现迁移学习。然而，使用脚本2后我无法再加载预训练的参数，迁移学习也失败了（在最初几轮训练的验证集上的mAP值非常低）。我不明白为什么“模型 = 模型.yaml, pretrain = yolo.pt”这种方式加载的预训练模型参数不能复制到多个GPU上并完成参数的初始化？我有哪些有效的方法可以在多GPU设置中，将预训练模型的参数加载到自定义网络中？
脚本1：

# Build a custom model from YAML, transfer pretrained weights to it and start training on single gpu 
yolo detect train model=yolov8_custom.yaml pretrained=yolov8s.pt device=0

脚本2：

# Build a custom model from YAML, transfer pretrained weights to it and start training on single gpu 
yolo detect train model=yolov8_custom.yaml pretrained=yolov8s.pt device=0, 1

[glenn-jocher]

@Stephen-Hao it seems like the issue might be related to the multi-GPU setup. Ensure that your environment supports multi-GPU training and that the device argument is correctly formatted without spaces, like device=0,1. If the problem persists, consider checking the compatibility of your custom YAML with multi-GPU configurations. For further details, refer to the Ultralytics documentation.

[Stephen-Hao]

OK，Thank for your reply!

[glenn-jocher]

@Stephen-Hao thank you for your interest! For multi-GPU training, ensure your environment supports it and use device=0,1 without spaces. If issues persist, verify your custom YAML compatibility with multi-GPU setups. For more details, refer to the Ultralytics documentation.

[ZZHbreeze]

Hi, I would like to ask if I can modify the number of epochs during breakpoints, i.e. can I increase or decrease the number of epochs? How can I do that?

[glenn-jocher]

@ZZHbreeze to modify the number of epochs during training, you can resume from a checkpoint and specify a new number of epochs. Use the resume=True argument and adjust the epochs parameter as needed.

[ZZHbreeze]

Do you mean that I trained for 200 rounds, but I realized that it didn't converge at 199 rounds, can I stop, save the last.pt, and then modify the epoch count, and then turn on RESUME?

[glenn-jocher]

Yes, you can stop training, save the last checkpoint, and then resume with a modified epoch count. Simply set resume=True and specify the new number of epochs when you restart.

[ZZHbreeze]

I would also like to ask two questions, the first one, my dataset has more than 30,000 training sets, what which model of pre-training weights is recommended?
Secondly, what hyperparameters can I go ahead and tune as my convergence rate is very slow while training? For example, now that I understand the two hyperparameters workers and cache, what other parameters can I tune to speed up the convergence of my model?

[glenn-jocher]

For your dataset with over 30,000 images, starting with a pretrained model like YOLO11n.pt is recommended. To improve convergence, consider tuning hyperparameters such as learning rate, momentum, and weight decay. Adjusting batch size and using techniques like cosine learning rate scheduling can also help.

[akai-takumi]

Hi, when I train the yolov8 model, the training parameter printed out is ‘augment=False’, does it mean that data augmentation is not enabled during training?
However, I saw some hyper parameter settings related to image enhancement in the train section of the website, I would like to ask if there is any default data enhancement setting during model training, I saw that the train section does not introduce ‘augment’ parameter, but the ‘predict’ section does introduce augment.
I would like to ask if it is possible to enable the built-in data augmentation by setting the parameter ‘augment=True’ during the training?
Looking forward to your answer!

[glenn-jocher]

@akai-takumi data augmentation is enabled by default during training in YOLO models. The 'augment' parameter you see is specific to prediction mode. For training, augmentation techniques are applied automatically based on the hyperparameters set in the configuration. You don't need to set 'augment=True' for training, as it's already integrated. For more details, you can refer to the training documentation.