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! 🚀

[Kannmu]

你好！请问如何在python中使用Ultralytics库来简单的进行灰度图训练yolo11模型？我的数据集是完整的3通道彩色图片，请问有没有什么方便的方法来完成？

[Elliot696]

The documentation mentions that erasing is a Classification only parameter, but erasing: 0.4 appears in the args.yaml that is automatically saved at the end of the training of my detection task, and I want to make sure that this parameter is in effect in the detection task

[JIUBAKAIDA]

你好，When training a multi-class segmentation task with YOLO, I only see overall metrics like Precision (P) and Recall (R) in the results. How can I modify the code to display classification accuracy for each individual class? Additionally, I'm unable to configure parameters for the seg_loss during training setup—how can I resolve this issue?

[EduardoNew]

Can I implement YOLOv7 training through a script? If so, how to do it?

[htwz-wxd]

from ultralytics import YOLO

您好，我使用以下配置来训练识别鸟的模型，但识别效果并不准确，因为鸟在实际场景中占到的像素点很小，就像一个小黑点，这个情况会造成很多误识别，比如地上的草或者小路灯，我想通过运动检测能力来增强模型的识别能力，但是不知道怎么加这个参数，您给给出一些建议吗？
model = YOLO('yolo11n.yaml')
results = model.train(
data="data.yaml",
epochs=500,
imgsz=1280,
device="1",
batch=16,
workers=16,# 增加数据加载线程数（建议设为 CPU 逻辑核心数的 2-4 倍）
amp=True, # 混合精度
max_det=10,
multi_scale=True #通过在训练期间将图像尺寸（imgsz）增大或减小最多 0.5 倍来启用多尺度训练
)

[Aether921]

May I ask if I want to modify the strategy of saving the best weights during segmentation model training, for example, it seems that only P, R, MAP, MAP50-95 can add weights by default? I want to save the model weights that perform best on IOU during validation. What should I do?

[wangxu-lab]

这里有关imgsz参数的说明是什么意思啊？
在yolov11和obb中，训练和预测时，有关图像预处理的大小调整中，所使用的算法是什么呢？是保留长宽比的缩放，还是直接拉伸式的缩放（不保留长宽比）？

[panhu]

请问，若是多类别目标检测，是否可以设置class_weights 或 cls_pw 参数，如何设置？

[zhu19971001]

from ultralytics import YOLO

Load a model

model = YOLO("/home/objdet/Ultralytics/ultralytics/cfg/models/26/yolo26l.yaml").load("/home/objdet/Ultralytics/yolo26l.pt")

Train the model with 2 GPUs

results = model.train(data="/home/objdet/data/Utralytics/dataset.yaml",
epochs=40,
imgsz=[1024, 512],
rect=True,
device=[0, 1, 2 , 3],
seed=42,
batch=48,
workers=16,
cache=True,
project="/home/objdet/Ultralytics/train/log",
name="20260115",
verbose=False,
close_mosaic=4,
optimizer="SGD",
lr0=0.01,
lrf=0.01,
cos_lr=False,
amp=True,
scale=0.2,
mosaic=1.0,
mixup=0.0,
copy_paste=0.1)

WARNING ⚠️ 'rect=True' is incompatible with Multi-GPU training, setting 'rect=False'
�[34m�[1mDDP:�[0m debug command /root/miniforge3/envs/yolo/bin/python -m torch.distributed.run --nproc_per_node 4 --master_port 35617 /root/.config/Ultralytics/DDP/_temp_ury34pjp140172230853920.py
Ultralytics 8.4.2 🚀 Python-3.9.23 torch-2.0.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3090, 24260MiB)
CUDA:1 (NVIDIA GeForce RTX 3090, 24260MiB)
CUDA:2 (NVIDIA GeForce RTX 3090, 24260MiB)
CUDA:3 (NVIDIA GeForce RTX 3090, 24260MiB)
Transferred 1080/1092 items from pretrained weights
�[34m�[1mAMP: �[0mrunning Automatic Mixed Precision (AMP) checks...
�[34m�[1mAMP: �[0mchecks passed ✅
WARNING ⚠️ updating to 'imgsz=1024'. 'train' and 'val' imgsz must be an integer, while 'predict' and 'export' imgsz may be a [h, w] list or an integer, i.e. 'yolo export imgsz=640,480' or 'yolo export imgsz=640'

This is my train configs and the some warnings about my rect_input_shape(1024,512), I want to know whether yolo26 can be trained with "rect=True" on multi GPU and single GPU?

[LOXYVE]

为什么云GPU(Linux系统)里训练时，即使pretrained=False，还是会自动下载最新的权重文件，难道训练时还是会采用已有的权重吗？
但是在Windows系统里，pretrained=False是有用的

[zhu19971001]

应该是你指定了要加载权重，你可以手动下载预训练权重到本地 发自我的iPhone

…

------------------ Original ------------------ From: kn ***@***.***> Date: Fri,Jan 16,2026 11:16 AM To: ultralytics/ultralytics ***@***.***> Cc: Zhu guoqing ***@***.***>, Comment ***@***.***> Subject: Re: [ultralytics/ultralytics] zh/modes/train/ (Discussion #8251) 为什么云GPU(Linux系统)里训练时，即使pretrained=False，还是会自动下载最新的权重文件，难道训练时还是会采用已有的权重吗？ 但是在Windows系统里，pretrained=False是有用的 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[glenn-jocher]

在全新的 Linux 云环境里，如果你传的是 model=yolo26n.pt（或 model=yolo26n 会自动解析成 .pt），那它本质上就是“预训练权重文件”，不存在时会先自动下载到本地再开始训练；pretrained=False 只影响用 model=*.yaml 搭建网络时是否加载预训练权重，并不会阻止下载你指定的 .pt 模型文件。参数优先级/合并规则也可以参考 Configuration reference。

yolo detect train data=your.yaml model=yolo26n.yaml pretrained=False

from ultralytics import YOLO
model = YOLO("yolo26n.yaml")
model.train(data="your.yaml", pretrained=False)

如果你已经用的是 .yaml 但仍在下载，请把你实际运行的完整命令（文本）和 yolo checks 输出贴出来，方便定位是哪一步触发了下载。

[LOXYVE]

同样的训练代码，Linux云环境下，会自动下载最新权重，并且自动生成runs/detect/predict文件夹，windows环境下不会下载最新权重，也不会生成predict文件夹 mytrain.py: model = YOLO('yolov8n.yaml') results = model.train(     data='SSLAD.yaml',     epochs=100,     imgsz=640,     workers=2,     pretrained=False,     batch=32 ) SSLAD.yaml： path: SSLAD # dataset root dir train: images/train # train images (relative to 'path') 5985 images val: images/val # val images (relative to 'path') 1496 images names:   0: Pedestrian       1: Cyclist       2: Car                   3: Truck             4: Tram             5: Tricycle 当运行在window环境下打印： (base) PS D:\Desktop\ultralytics-main> python mytrain.py New https://pypi.org/project/ultralytics/8.4.6 available Update with 'pip install -U ultralytics' Ultralytics 8.4.3 Python-3.12.7 torch-2.9.1+cpu CPU (Intel Core Ultra 7 155H) engine\trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=32, bgr=0.0, box=7.5, cache=False, cfg=None, classes=None, close_mosaic=10, cls=0.5, compile=False, conf=None, copy_paste=0.0, copy_paste_mode=flip, cos_lr=False, cutmix=0.0, data=SSLAD.yaml, degrees=0.0, deterministic=True, device=cpu, dfl=1.5, dnn=False, dropout=0.0, dynamic=False, embed=None, epochs=100, erasing=0.4, exist_ok=False, fliplr=0.5, flipud=0.0, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.01, lrf=0.01, mask_ratio=4, max_det=300, mixup=0.0, mode=train, model=yolov8n.yaml, momentum=0.937, mosaic=1.0, multi_scale=0.0, name=train13, nbs=64, nms=False, opset=None, optimize=False, optimizer=auto, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=False, profile=False, project=None, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=D:\Desktop\ultralytics-main\runs\detect\train13, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.5, seed=0, shear=0.0, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.1, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.0, warmup_momentum=0.8, weight_decay=0.0005, workers=2, workspace=None Overriding model.yaml nc=80 with nc=6 from n params module arguments 0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2] 1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2] 2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True] 3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2] 4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True] 5 -1 1 73984 ultralytics.nn.modules.conv.Conv [64, 128, 3, 2] 6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True] 7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2] 8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True] 9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5] 10 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] 11 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1] 12 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1] 13 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] 14 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1] 15 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1] 16 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2] 17 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1] 18 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1] 19 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2] 20 [-1, 9] 1 0 ultralytics.nn.modules.conv.Concat [1] 21 -1 1 493056 ultralytics.nn.modules.block.C2f [384, 256, 1] 22 [15, 18, 21] 1 752482 ultralytics.nn.modules.head.Detect [6, 16, None, [64, 128, 256]] YOLOv8n summary: 130 layers, 3,012,018 parameters, 3,012,002 gradients, 8.2 GFLOPs Freezing layer 'model.22.dfl.conv.weight' train: Fast image access (ping: 0.00.0 ms, read: 25.510.5 MB/s, size: 287.8 KB) train: Scanning D:\Desktop\ultralytics-main\SSLAD\labels\train... 33 images, 0 backgrounds, 0 corrupt: 1% ──────────── 33/5000 96.train: Scanning D:\Desktop\ultralytics-main\SSLAD\labels\train... 89 images, 1 backgrounds, 0 corrupt: 2% ──────────── 89/5000 225 运行在Linux云环境下：  (torch) ***@***.***:/data/coding/ultralytics-main# python mytrain.py New https://pypi.org/project/ultralytics/8.4.6 available 😃 Update with 'pip install -U ultralytics' Ultralytics 8.4.3 🚀 Python-3.10.16 torch-2.7.1+cu126 CUDA:0 (Tesla P4, 8109MiB) engine/trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=32, bgr=0.0, box=7.5, cache=False, cfg=None, classes=None, close_mosaic=10, cls=0.5, compile=False, conf=None, copy_paste=0.0, copy_paste_mode=flip, cos_lr=False, cutmix=0.0, data=SSLAD.yaml, degrees=0.0, deterministic=True, device=None, dfl=1.5, dnn=False, dropout=0.0, dynamic=False, embed=None, epochs=100, erasing=0.4, exist_ok=False, fliplr=0.5, flipud=0.0, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.01, lrf=0.01, mask_ratio=4, max_det=300, mixup=0.0, mode=train, model=yolov8n.yaml, momentum=0.937, mosaic=1.0, multi_scale=0.0, name=train, nbs=64, nms=False, opset=None, optimize=False, optimizer=auto, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=False, profile=False, project=None, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=/data/coding/ultralytics-main/runs/detect/train, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.5, seed=0, shear=0.0, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.1, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.0, warmup_momentum=0.8, weight_decay=0.0005, workers=2, workspace=None Overriding model.yaml nc=80 with nc=6 from n params module arguments 0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2] 1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2] 2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True] 3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2] 4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True] 5 -1 1 73984 ultralytics.nn.modules.conv.Conv [64, 128, 3, 2] 6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True] 7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2] 8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True] 9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5] 10 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] 11 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1] 12 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1] 13 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] 14 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1] 15 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1] 16 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2] 17 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1] 18 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1] 19 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2] 20 [-1, 9] 1 0 ultralytics.nn.modules.conv.Concat [1] 21 -1 1 493056 ultralytics.nn.modules.block.C2f [384, 256, 1] 22 [15, 18, 21] 1 752482 ultralytics.nn.modules.head.Detect [6, 16, None, [64, 128, 256]] YOLOv8n summary: 130 layers, 3,012,018 parameters, 3,012,002 gradients, 8.2 GFLOPs Freezing layer 'model.22.dfl.conv.weight' AMP: running Automatic Mixed Precision (AMP) checks... Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 1% ──────────── 64.0KB/5.3MB 180.0Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 4% ──────────── 224.0KB/5.3MB 1.5MDownloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 9% ━─────────── 512.0KB/5.3MB 2.5MDownloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 25% ━━━───────── 1.3/5.3MB 8.4MB/sDownloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 65% ━━━━━━━╸──── 3.4/5.3MB 21.0MB/Downloading https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt to 'yolo26n.pt': 100% ━━━━━━━━━━━━ 5.3MB 9.1MB/s 0.6s AMP: checks passed ✅ train: Fast image access ✅ (ping: 0.0±0.0 ms, read: 2512.8±900.0 MB/s, size: 287.8 KB) train: Scanning /data/coding/ultralytics-main/SSLAD/labels/train.cache... 5000 images, 33 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 5000/5000 1.0Git/s 0.0s   黄子龙 ***@***.***  

…

------------------ 原始邮件 ------------------ 发件人: "Glenn ***@***.***>; 发送时间: 2026年1月18日(星期天) 凌晨5:04 收件人: ***@***.***>; 抄送: ***@***.***>; ***@***.***>; 主题: Re: [ultralytics/ultralytics] zh/modes/train/ (Discussion #8251) 在全新的 Linux 云环境里，如果你传的是 model=yolo26n.pt（或 model=yolo26n 会自动解析成 .pt），那它本质上就是“预训练权重文件”，不存在时会先自动下载到本地再开始训练；pretrained=False 只影响用 model=*.yaml 搭建网络时是否加载预训练权重，并不会阻止下载你指定的 .pt 模型文件。参数优先级/合并规则也可以参考 Configuration reference。 yolo detect train data=your.yaml model=yolo26n.yaml pretrained=False from ultralytics import YOLO model = YOLO("yolo26n.yaml") model.train(data="your.yaml", pretrained=False) 如果你已经用的是 .yaml 但仍在下载，请把你实际运行的完整命令（文本）和 yolo checks 输出贴出来，方便定位是哪一步触发了下载。 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***>

[glenn-jocher]

你这两点差异主要不是 Windows vs Linux，而是 CPU vs CUDA/AMP：Linux 上有 CUDA 时会跑 AMP 自检，过程中可能会下载一个参考权重（你日志里下载的 yolo26n.pt 就是在 AMP: running ... checks 这一步触发的），而 Windows 这边是 torch-...+cpu，通常不会触发同样的下载；另外 runs/detect/predict* 只会在你调用 predict()/yolo predict 时生成，单纯 train() 只会生成 runs/detect/train*（可参考训练模式文档）。

如果你想验证/规避这一步下载，可以在 Linux 训练时临时关掉 AMP 试下：

results = model.train(data="SSLAD.yaml", epochs=100, imgsz=640, workers=2, pretrained=False, batch=32, amp=False)

若仍有不一致，麻烦把两边环境的 yolo checks（文本）都贴出来，重点看 ultralytics 安装路径是否一致以排除多版本/路径覆盖问题。

[caoyue2020]

请问不同版本的ultralytics库本身会有差异吗，如果我需要训练调整不同版本的yolo，需要去下载他们各自的仓库吗

[glenn-jocher]

会有差异：ultralytics 是持续迭代的库，同一套代码里可通过切换 model=*.pt/*.yaml 来训练我们支持的不同 Ultralytics YOLO 代际（一般不需要分别去下载多个仓库）；如果你需要复现某个旧行为/旧结果，建议直接固定安装版本（如 pip install "ultralytics==X.Y.Z" 或从 tag 安装），而如果你要训练的是完全独立维护的实现（例如某些历史 YOLO 代码库），通常需要用对应仓库；训练入口与参数可参考 Train 模式文档，也欢迎把你具体想训练的 YOLO 版本和命令贴在本讨论里方便我们确认。

[curry-hua]

我在platform探索时，为什么不能把我标注好的数据集上传（已经包含txt文件），而且我发现上传之前我的图片排列是有顺序的，标注起来很方便，但是上传之后，image集就变得混乱起来了，标注起来很不方便

[glenn-jocher]

欢迎直接在这个讨论里继续补充问题，团队能看到。Ultralytics Platform 可以上传已标注数据集，但需要按标准 YOLO 结构打包上传，包含 images/、labels/ 和 data.yaml，否则平台不会把你的 .txt 自动识别为标签；另外上传后图片显示顺序是按数据集页的排序规则来的，你可以切到 Name A-Z 或 Oldest 来找回更接近原始顺序的浏览方式。你可以先对照一下 Platform Datasets 文档，如果仍然异常，贴一下压缩包目录结构或一小份样例，我们继续帮你看。 (docs.ultralytics.com)

[curry-hua]

自动选择算法优先考虑具有以下特征的 GPU：1.更低的电流利用率，我觉得这里的表述容易误导读者，换成更低的功耗负载的GPU或许更好一些，或者换成其他表述

[glenn-jocher]

感谢指出，这里的“更低的当前利用率”主要指 GPU utilization，不是单纯指功耗，中文表述确实可以更清晰；我们会考虑在训练文档里调整为“优先选择利用率更低且可用显存更多的 GPU”，也欢迎继续直接在这里反馈，方便 Ultralytics 团队统一查看。