Hey there 👋, it looks like you're encountering a RuntimeError related to torch.cat(): it expects a non-empty list of tensors but received an empty one. This error often occurs when the model doesn't detect any objects in the validation set, leading to an empty list of results being passed to torch.cat().

To troubleshoot, consider the following steps:

• Ensure your dataset is properly loaded and accessible to YOLOv8 during validation.

• Check if the provided data path in your config file points to valid dataset directories.

• Temporarily reduce the conf threshold in your training script to see if it starts detecting objects. For example, lowering it to 0.01 might help:

  yolo train data=coco128.yaml model=yolov8n.yaml conf=0.01

If the issue persists, it could be helpful to share more details about your setup, including the dataset and configuration files, so we can offer more targeted advice! 😊

感谢回复，已经解决，问题在于数据集xml转yolo失败。

太棒了，很高兴听到您解决了问题！🎉 数据集转换问题确实会导致一些头疼的错误。如果未来您有任何关于模型训练或部署的疑问，或者需要关于数据准备的更多建议，随时欢迎您回来提问。🙂

下次遇到XML转YOLO格式失败时，可以尝试使用我们提及的JSON2YOLO工具来简化流程。这个工具能帮助您轻松转换不同格式的数据集。

祝您在接下来的项目中一切顺利！

Yes, the YOLOv8 pre-trained model supports training on your own dataset, even if it was originally in a different annotation format like polygon annotated JSON. You'll need to convert your dataset to the YOLO format first. Once your dataset is in YOLO format, you can use it for training by specifying your dataset in the data YAML file and then proceeding with training as usual.

Here's a quick example on how to train with your custom dataset after conversion:

# Load your model and train on your custom dataset
yolo detect train data=your_dataset.yaml model=yolov8n.pt epochs=100 imgsz=640

Make sure your your_dataset.yaml correctly points to your training and validation data in the YOLO format. Happy training! 🚀

I have now annotated a batch of data (in JSON format) using the polygon annotation tool, which I want to use for object detection tasks. Does YOLOv8's object detection pre-trained model support polygon-annotated data? YOLOv5 does not support polygon-annotated data. (Or YOLOv8 supports polygon annotation data, pay attention to the separation from the instance when converting json to YOLO?)

Hey there! 👋 YOLOv8, similar to YOLOv5, fundamentally works with bounding boxes for object detection and doesn't natively support polygon annotations directly in its training process. But, don't worry! You can convert your polygon-annotated data into bounding boxes following a simple approach:

1. Convert your polygon annotations to the bounding box format by calculating the minimum and maximum coordinates enclosing your polygon.

For example, if you have a polygon annotation in JSON:

{
  "shapes": [
    {
      "label": "YourObject",
      "points": [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]
    }
  ]
}

Convert this to a bounding box by finding the min and max of x and y coordinates.

2. Once converted to bounding boxes, format your data in the YOLO format:

<object-class> <x_center> <y_center> <width> <height>

Make sure to normalize x_center, y_center, width, and height by the image width and height to convert them into relative coordinates.

Remember, the transition from polygons to bounding boxes might not capture the exact essence of very irregular shapes but works well for a wide range of applications. Train your model as usual after conversion! 🚀

Let us know if you need any further assistance. Happy training!

JSON2YOLO the "general_json2yolo" and "labelbox_json2yolo" in the tool, the two scripts are respectively the JSON format of the dataset of the task and the YOLO format of the dataset of the task (for example, the format of the JSON dataset of instance segmentation is accurately changed to the YOLO dataset format of the target detection).

Hey there! 👋 It looks like you're exploring the tools general_json2yolo and labelbox_json2yolo for converting JSON dataset formats to YOLO format, specifically for instance segmentation to object detection tasks. That's an exciting step towards customizing your models! 🚀

When converting, ensuring the bounding boxes derived from your polygon annotations accurately encompass your objects of interest is crucial. This conversion process retains essential object details while complying with YOLO's detection format.

Here's a quick Python code snippet illustrating how you might convert JSON polygon annotations to YOLO format bounding boxes:

# Assuming 'annotations' is your list of polygon annotations from JSON
for annotation in annotations:
    # Find the min and max coordinates to form a bounding box
    x_coordinates = [point[0] for point in annotation['points']]
    y_coordinates = [point[1] for point in annotation['points']]
    bbox = [min(x_coordinates), min(y_coordinates), max(x_coordinates), max(y_coordinates)]
    
    # Convert to YOLO format (x_center, y_center, width, height)
    bbox_yolo = convert_to_yolo_format(bbox, image_width, image_height)
    
    # Save or use the bbox_yolo for your YOLO training data

Remember, converting annotations formats might require some tweaks depending on the specifics of your dataset. Always check to ensure the converted bounding boxes are accurate and represent your objects well.

Feel free to reach out if you have further questions or need more help. Happy training! 🤗

@gulanyun it seems like your training results are showing low mAP scores. To improve this, consider checking your dataset quality, ensuring proper annotation, and adjusting hyperparameters like learning rate or batch size. For more detailed guidance, you might want to explore the Ultralytics documentation on training strategies.

检测视频后，保存检测视频却保存出一个0字节的avi格式视频！我想顺利保存出正确的视频，并且希望能用预测时的参数指定我想保存的视频格式。

@xiao5676wen 在视频检测保存为0字节的情况下，可能与编码器设置或输出路径权限有关。请确保 ffmpeg 安装正确，因为它是保存视频的依赖工具。同时，参数 save 无法直接指定格式，默认保存为 .mp4。如需其他格式，建议后处理时用工具如 ffmpeg 转换格式。运行时，检查日志是否有错误提示，帮助排查问题。

@Leeeeah 要修改训练中的 IoU 值，您可以通过调整配置参数 iou_t，它表示正样本的 IoU 阈值。

例如，在 Python 代码中，您可以这样设置：

model.train(data="dataset.yaml", epochs=50, iou_t=0.7)

或者使用命令行界面（CLI）：

yolo detect train data=dataset.yaml epochs=50 iou_t=0.7

更多参数详情可参考Ultralytics配置文档. 如果您有其他问题，欢迎继续咨询！

@legend-zhen to convert a .pt Ultralytics YOLO model to .pth format, simply rename the file (mv model.pt model.pth) as both formats store PyTorch state dicts. For official export options like ONNX or TensorRT, see the Export documentation.

For commercial use, remember AGPL-3.0 requires open-sourcing derivatives or obtaining an Enterprise License from Ultralytics.

@legend-zhen to implement YOLOv8 with HRNet in a top-down pose estimation pipeline:

1. Use YOLOv8 Detect to get bounding boxes for persons
2. Crop detected regions and pass each to HRNet for keypoint detection
3. Process results sequentially or batch-process crops

Here's a minimal implementation sketch:

from ultralytics import YOLO
import hrnet_lib  # Your HRNet setup

detector = YOLO('yolov8n.pt')
pose_model = hrnet_lib.load_model()

results = detector(source_image)
for box in results[0].boxes.xyxy:  # Get detection boxes
    crop = source_image.crop(box)
    keypoints = pose_model(crop)  # HRNet inference

For complete guidance, see our Pose Estimation documentation and Python API examples.

@legend-zhen Hello! Improving classification accuracy while detection boxes are good often involves focusing on aspects that enhance feature representation for distinguishing between classes. Here are a few areas you could explore:

1. Data Augmentation: Review and potentially increase augmentations that affect appearance more than geometry, like color space adjustments (hsv_h, hsv_s, hsv_v).
2. Hyperparameter Tuning: Consider slightly increasing the classification loss gain hyperparameter (cls) to give classification more weight during training. You might also experiment with training for more epochs.
3. Model Size: If you are using a smaller model (like YOLO11n or YOLO11s), trying a larger one (YOLO11m, YOLO11l, YOLO11x) could provide the capacity needed to better differentiate between your 40 classes.
4. Dataset Review: Ensure your dataset has sufficient and balanced examples for each class, especially for classes that are commonly confused. High-quality, diverse images are key.

You can find more details on adjusting hyperparameters and training strategies in our Tips for Model Training guide. Good luck with your improvements!

@legend-zhen Thanks for the traceback. Your checkpoint was saved with custom code (ultralytics.nn.add_modules) from a modified Ultralytics repo, but you’re loading it with the pip-installed package where that module doesn’t exist. Fix by either installing your modified repo into the same environment, or exporting to a format that doesn’t require the original Python classes:

# Option A: load with the same modified code
pip uninstall -y ultralytics
pip install -e path\to\your_modified_ultralytics

# Option B: export once from the environment where it loads, then use the artifact
yolo export model="D:\YOLO\YOLO11\ultralytics-main\runs\detect\train8\weights\best.pt" format=onnx

Please also run and paste the text output of:

yolo checks

to confirm you’re not mixing a local repo and a pip install; compare the Ultralytics install path it prints with the paths in your traceback. Export formats and usage are summarized in the Export guide and general troubleshooting tips are in Troubleshooting Common YOLO Issues.