models/

[giscus[bot]]

models/

Discover a variety of models supported by Ultralytics, including YOLOv3 to YOLOv10, NAS, SAM, and RT-DETR for detection, segmentation, and more.

https://docs.ultralytics.com/models/

[learningDude1]

I've already installed Ultralytics in a separate Conda environment and trained a YOLOv8 model. Now I want to use the YOLOv10 model. Do I need to create a new environment and set it up from scratch, or can I train or use YOLOv10 in the existing YOLOv8 environment?

[glenn-jocher]

You can use YOLOv10 in the same environment where you have YOLOv8 installed. Simply load the YOLOv10 model using the Ultralytics library and proceed with training or inference as needed. No need to create a new environment.

[huilin66]

is there a reference yaml for yolov7 and yolov4, like yolov6.yaml?

[glenn-jocher]

@huilin66 you can find the reference YAML files for YOLOv7 and YOLOv4 in the Ultralytics GitHub repository under the models directory. If you need further details, please refer to the Ultralytics documentation.

[ViniciusVViana]

I need help. I use this YOLO architecture in a university project, and to make the article i need to specify the numbem of hidden layers, and i don't how many there are.

[glenn-jocher]

@ViniciusVViana for details on the number of hidden layers in YOLO architectures, you can refer to the model configuration files in the Ultralytics repository. Each model's YAML file specifies its architecture, including layers. If you need further assistance, please check the documentation or community forums.

[Dileep-utl]

I am trying to train my yolov8s-worldv2.pt with custom data on colab with TPU as engine but getting error as "RuntimeError: Cannot set version_counter for inference tensor " tried with most possible version but even after setup TPU still facing same issue. I need help with it so i can you TPU to train models

!pip install cloud-tpu-client==0.10
!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
!pip install torch_xla --extra-index-url https://storage.googleapis.com/tpu-pytorch/wheels
!pip install ultralytics==8.3.24 # Install the latest version of Ultralytics

import torch
import torch_xla
import torch_xla.core.xla_model as xm

Print versions to confirm installation

print(f"PyTorch version: {torch.version}")
print(f"torch-xla version: {torch_xla.version}")
with output---->

PyTorch version: 2.5.0+cpu
torch-xla version: 2.5.0+libtpu

import torch_xla.core.xla_model as xm
device = xm.xla_device()
print(f"Using device: {device}")
with output---->
Using device: xla:0

results = model.train(data="lvis.yaml", epochs=2, imgsz=640, device=device)

output as error------->

RuntimeError: Cannot set version_counter for inference tensor

[glenn-jocher]

@Dileep-utl it seems like you're encountering a compatibility issue with TPU and PyTorch versions. Ensure that your PyTorch and torch-xla versions are compatible with TPU. You might want to check the official PyTorch XLA documentation for the correct setup. If the issue persists, consider using a GPU instead for training.

[Dileep-utl]

I am trying to train my yolov8s-worldv2.pt with custom data on colab with TPU as engine but getting error as "RuntimeError: Cannot set version_counter for inference tensor " tried with most possible version but even after setup TPU still facing same issue. I need help with it so i can you TPU to train models

!pip install cloud-tpu-client==0.10
!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
!pip install torch_xla --extra-index-url https://storage.googleapis.com/tpu-pytorch/wheels
!pip install ultralytics==8.3.24 # Install the latest version of Ultralytics

import torch
import torch_xla
import torch_xla.core.xla_model as xm

Print versions to confirm installation

print(f"PyTorch version: {torch.version}")
print(f"torch-xla version: {torch_xla.version}")
with output---->

PyTorch version: 2.5.0+cpu
torch-xla version: 2.5.0+libtpu

import torch_xla.core.xla_model as xm
device = xm.xla_device()
print(f"Using device: {device}")
with output---->
Using device: xla:0

results = model.train(data="lvis.yaml", epochs=2, imgsz=640, device=device)

output as error------->

RuntimeError: Cannot set version_counter for inference tensor

[glenn-jocher]

@Dileep-utl it seems you're encountering an issue with TPU compatibility. Currently, YOLO models are optimized for GPU usage. For TPU support, you might need to explore alternative configurations or consider using a GPU environment. For more details, please refer to our documentation: https://docs.ultralytics.com/models/.

[LiJiang97]

When using yolo11 for inference, what operations will the preprocessing process perform on the input image? Is it just scaling the image to 640? Which part is the operation file? Thank you

[glenn-jocher]

@LiJiang97 the preprocessing for YOLO11 typically involves resizing the input image to the specified imgsz (default 640) while maintaining aspect ratio by padding as needed. These operations are handled internally in the Ultralytics framework. You can explore the preprocessing logic in the ultralytics/models directory of the repository. Let us know if you need further assistance!

[hemanthmandava945]

@glenn-jocher @pderrenger
Car Segmentation on Reflectivity Images

What I'm doing:

Running inference with a pretrained YOLOv8 model to segment cars in the LiDAR reflectivity domain.
Detection performance (bounding boxes) looks good, but the segmentation masks aren’t very accurate.
The problem:

When I project these predicted masks onto the 3D point cloud, I see a lot of misclassified points (points that are not actually part of the car end up being labeled as car).
These noisy masks reduce the accuracy of any downstream tasks that rely on correct 3D segmentation.
Question:

Has anyone else dealt with similar mask inaccuracy issues when segmenting LiDAR-based 2D images?
Are there recommended strategies to improve segmentation masks on reflectivity images? (e.g., domain-specific data augmentation, fine-tuning from a LiDAR-focused checkpoint, multi-modal approaches, etc.)

Pallet Detection on Reflectivity Images

What I'm planning:

Train YOLOv8 to detect pallets in LiDAR reflectivity images (again, 512×128, single channel).
Pallets appear relatively small in these images.
Potential multi-modal approach:

Considering combining RGB camera images with LiDAR reflectivity data in the training set (even though the reflectivity images look more like grayscale).
My concern: Will mixing these modalities confuse the model or help it? Pallets are already small in lidar images, and might be even harder to identify in reflectivity data.
Questions:

Is it advisable to train on both RGB and reflectivity images at once, or should I keep them separate?
Does anyone have experience or tips on multi-modal YOLO training (camera + LiDAR reflectivity)?
If combining them is possible, any best practices for merging different modalities (e.g., input channels, data augmentation techniques, etc.)?

Additional
No response

[hemanthmandava945]

@glenn-jocher
could explain in more details,
I am working with Ouster LiDAR reflectivity images and aiming to evaluate the inference speed and performance of pretrained YOLOv8, YOLOv9, and YOLOv11 models for instance segmentation. However, I am facing issues when using the YOLO validation function (val), even though the visual inspection of inference results looks good. note: the model or running on lidar video segmenting cars very well and tracking of masks also performs good

My Understanding & Key Questions:
Fine-Tuning vs. Direct Evaluation:

I understand that fine-tuning means training a pretrained model on my dataset (LiDAR 2D images). However, my goal is to only validate the pretrained YOLO models without fine-tuning.
Does the poor validation performance indicate a need for fine-tuning, or is it possible that the pretrained models just do not generalize well to my LiDAR images?
Dataset & Annotation Format:

I have 50 annotated images (no separate training set, only validation).
The annotations are in YOLO format, where segmentation masks are represented as polygon coordinates normalized to image width and height. Example annotation:
0 0.478515625 0.4783950617283951 0.52734375 0.4783950617283951 0.52734375 0.6790123456790124 0.478515625 0.6790123456790124
Validation Issues:

When I run YOLO inference, the visual results look reasonable, and the model seems to segment objects correctly.
However, when using YOLO’s val function, the evaluation metrics are poor. What could be the reasons behind this discrepancy?
Performance Metrics to Focus On:

Since my goal is to compare YOLOv8, YOLOv9, and YOLOv11 on LiDAR reflectivity images in terms of inference speed and segmentation accuracy, what are the most relevant evaluation metrics I should consider?
I am currently looking at:
IoU (Intersection over Union)
F1 score
mAP (mean Average Precision)
FPS (Frames Per Second) for inference speed
Are there any specific metrics better suited for LiDAR-based segmentation?
What strategies would you recommend for properly evaluating segmentation models on LiDAR images?
Are there better methods to verify annotation alignment and ensure the YOLO val function produces meaningful results?

[glenn-jocher]

Hi there! 👋 Your observed discrepancy between visual results and validation metrics likely stems from a domain gap between COCO-pretrained models (RGB images) and LiDAR reflectivity data (single-channel). Here's a concise breakdown:

1. Domain Adaptation: Pretrained models struggle with LiDAR's unique characteristics. Fine-tuning (even briefly) on LiDAR data is strongly recommended (YOLO Train Docs)
2. Annotation Verification: Use yolo val with plots=True to visualize predictions vs. ground truth. Check mask alignment in LiDAR coordinates
3. Key Metrics: Focus on mAP50-95(M) for segmentation quality and FPS for speed. LiDAR-specific metrics like point-wise IoU could add value
4. Quick Fix: Try converting LiDAR to 3-channel (replicate single channel) to better match pretrained weights

For direct evaluation without fine-tuning, consider benchmarking against manually verified samples rather than relying solely on automated metrics. Our COCO-Seg validation example might help as reference. Let us know how it goes! 🚀

[hemanthmandava945]

@glenn-jocher
Issue:
When using YOLOv8 for instance segmentation, I’ve noticed that the predicted masks extend slightly beyond the true object boundaries. This results in overlapping masks when objects are close together and inaccurate measurements of object sizes and shapes.

Observations:

Oversized Masks: The masks often include extra pixels along the edges, sometimes producing “flat” boundaries—similar to known issues where masks align too closely with the bounding box edges.
Overlap with Adjacent Objects: Due to these extra pixels, masks of nearby objects tend to merge or overlap, which is problematic for applications requiring precise segmentation as i am projecting in 3d some of pixels segmented car points where projected on other objects .
Architectural Artifact: The issue appears inherent to the current segmentation head in YOLOv8, where the approximated boundaries may not capture fine details, especially for smaller objects.

is it possible to reduce the size of the mask like getting 90% of mask, as i don't require the mask till the edge of the car. i can get major pixels of car.

[hemanthmandava945]

this result of yolo inference on lidar data

[glenn-jocher]

Thank you for sharing these details. For mask size reduction in YOLOv8 segmentation, you can post-process predictions by applying a mask confidence threshold and morphological erosion. Here's a minimal example to shrink masks:

from ultralytics import YOLO
import cv2

model = YOLO('yolov8x-seg.pt')
results = model(your_image)
masks = results[0].masks.data.cpu().numpy()

# Apply erosion to shrink masks
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))  # Adjust kernel size as needed
eroded_masks = [cv2.erode(m, kernel) for m in masks]

For better domain adaptation, consider fine-tuning the segmentation head on LiDAR data using our Train docs. The pretrained COCO weights may struggle with LiDAR's unique reflectance patterns.

[matteobona]

Hi, Is it possibile to use a yolo-pose model (with a custom dataset and training) to detect simultaneously a class of objects with keypoints inside and a different class with no keypoints?. For example I need to detect a football pitch with some keypoints inside of it and the football players as simple bounding boxes. Is there a way to use a unique model instead of using two separate models (yolo-pose + yolo-detect)? for example putting at 0 0 0 any keypoints related to the players (but I think that this solution may confuse the model during the training)

[glenn-jocher]

Yes, you can train a single YOLO-pose model to detect both classes. For objects without keypoints (players), simply set all keypoint coordinates to zero in your dataset annotations. The model will learn to ignore these zero-value keypoints while still detecting bounding boxes for both classes. For implementation details, see the Pose Estimation task documentation on handling mixed annotations.

This approach is efficient and avoids the complexity of running two separate models, though we recommend thorough validation to ensure keypoint absence doesn't degrade detection performance for non-keypoint classes.

[Ranjith3436]

Hi Guys!, Could you please clarify
how you select best.pt ?
what is the parameter use for that?
how early Stop works?
sometime val/loss is going to high but earlystop doesn't stop training for classification?

[glenn-jocher]

best.pt is the epoch with the highest validation “fitness” metric; for detection/seg/pose it’s mAP50-95, for classification it’s top‑1 accuracy, and Early Stop watches the same fitness (not val_loss) and stops after patience epochs without improvement (set via patience). Rising val_loss won’t trigger stopping if accuracy is still improving; see how fitness/metrics are computed in the Insights on Model Evaluation and Fine-Tuning guide: https://docs.ultralytics.com/guides/model-evaluation-insights/.