help/

[giscus[bot]]

help/

Find comprehensive guides and documents on Ultralytics YOLO tasks. Includes FAQs, contributing guides, CI guide, CLA, MRE guide, code of conduct & more.

https://docs.ultralytics.com/help/

[anirudhjbabu1]

I want to save the image in which the object is detected and not detected into different folders.

[anirudhjbabu1]

thanks

[anirudhjbabu1]

thanks but can you help with the code. I already tried them, there is no change

[pderrenger]

@anirudhjbabu1 certainly! Below is a Python code snippet that demonstrates how to save images with and without detected objects into separate folders using the Ultralytics YOLOv8 model. Make sure to replace 'path/to/yolov8n.pt' with the actual path to your YOLOv8 model and adjust the source and destination folder paths as needed.

import os
from pathlib import Path
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('path/to/yolov8n.pt')

# Define source directory and destination directories for detected and not detected
source_dir = Path('path/to/source/images')
detected_dir = Path('path/to/save/detected/images')
not_detected_dir = Path('path/to/save/not_detected/images')

# Create destination directories if they don't exist
os.makedirs(detected_dir, exist_ok=True)
os.makedirs(not_detected_dir, exist_ok=True)

# Process each image in the source directory
for img_path in source_dir.glob('*.jpg'):  # adjust the glob pattern for different image formats
    # Run inference
    results = model(img_path)

    # Check for detections
    if len(results[0].boxes) > 0:
        save_path = detected_dir / img_path.name
    else:
        save_path = not_detected_dir / img_path.name

    # Save image
    results[0].orig_img.save(save_path)

    print(f"Image {img_path.name} saved to {save_path}")

This script will iterate over all JPEG images in the source_dir, run inference on them, and then save them to either the detected_dir or not_detected_dir based on whether any objects were detected. Adjust the file pattern in source_dir.glob('*.jpg') if you're working with a different image format.

Make sure you have the latest version of the Ultralytics YOLOv8 library installed, as the API may differ in older versions. If you encounter any issues, please check the documentation or raise an issue on the GitHub repository for further assistance.

[swarnalathayv]

it is throwing an error that numpy.ndarray has no object save

[pderrenger]

Hi @swarnalathayv,

Thank you for reaching out! It looks like you're encountering an error because numpy.ndarray objects do not have a save method. To save images, you should use the appropriate library functions. Here's a quick example using the PIL library to save images:

from PIL import Image
import numpy as np

# Assuming 'results[0].orig_img' is a numpy array
image_array = results[0].orig_img

# Convert numpy array to PIL Image
image = Image.fromarray(image_array)

# Save the image
image.save(save_path)

If you continue to experience issues, please ensure you are using the latest versions of torch and ultralytics:

pip install --upgrade torch ultralytics

If the problem persists, could you please provide a minimum reproducible example? This will help us investigate the issue more effectively. You can find guidance on creating a minimum reproducible example here.

Feel free to reach out if you have any further questions. Happy coding! 😊

[AnandSrikumar]

I'm seeking clarification regarding the imgsz parameter in YOLO (You Only Look Once) and its impact on image resizing and bounding boxes. In my dataset, all images have a consistent size of 1920x1080 pixels.

If I set the imgsz parameter to 640, will the images be internally downscaled to 640x640 pixels by YOLO during training or inference? In the context of this resizing, I'm curious about the effect on bounding boxes. Do their coordinates change, or does YOLO handle the calculation of new bounding boxes internally to accommodate the downscaled images?

I want to ensure that I understand how YOLO manages the resizing process and its implications for object detection accuracy. Any insights or pointers to relevant documentation would be greatly appreciated.

Thank you.

[pderrenger]

@AnandSrikumar when you set the imgsz parameter to 640 in YOLOv8, the images are indeed resized internally during both training and inference. The resizing maintains the aspect ratio of the original images, so they will not necessarily become 640x640 pixels unless they were square to begin with. Instead, the longer side of the image is resized to 640 pixels, and the shorter side is resized proportionally.

The bounding boxes are also scaled accordingly. YOLOv8 handles the resizing of both the images and the bounding boxes internally, so the coordinates of the bounding boxes are adjusted to match the resized images. This ensures that the object detection remains accurate despite the change in image dimensions.

The resizing process is crucial for maintaining consistency across different image sizes and for optimizing the speed and memory usage during training and inference. It's also important for leveraging pre-trained models that expect a specific input size.

For more detailed information on how YOLOv8 handles image resizing and its impact on bounding boxes, you can refer to the official documentation and guides at Ultralytics YOLOv8 Documentation. 📚

[AnandSrikumar]

Thank you so much for the help. I also want to know if we can have s3 bucket paths in data.yaml for model training? I have all the images in s3 buckets. I have the s3 folder structure like s3://bucket_name/yolo/train/images for images and s3://bucket_name/yolo/train/labels for the labels.

[pderrenger]

@AnandSrikumar yes, YOLOv8 supports training with datasets stored in S3 buckets. You can specify your S3 bucket paths directly in your data.yaml file for the train and val datasets. Make sure your environment is configured with the necessary AWS credentials and permissions to access the S3 bucket.

Here's an example of how your data.yaml might look:

train: s3://bucket_name/yolo/train/images
val: s3://bucket_name/yolo/val/images

# Classes
nc: 80  # number of classes
names: ['class1', 'class2', ..., 'classN']  # class names

Ensure that your labels are also accessible in the corresponding labels folders within the same S3 paths. YOLOv8 will automatically look for labels in a directory named labels adjacent to the images directory specified in the data.yaml.

[jjwallaby]

Hi, WRT inference/predict in yolov8 how can you obtain the run number ? Or the folder to /run/detect/predictXX where XX is the sequential number ?

Reason would like to automatically get the image with all the bounding boxes.

example

/run/detect/predict46
/run/detect/predict47

Using :-
results = model('image1.jpg', save_crop=True,show=False,save=True,conf=0.50,iou=0.8)

Thanks

[pderrenger]

@jjwallaby hi there! 👋 When you run inference with save=True, the results are saved in a new folder under runs/detect/exp*, where * is an automatically incremented run number. To programmatically obtain the latest run directory, you can use the following approach:

from pathlib import Path

# After running inference
run_dirs = sorted(Path('runs/detect').glob('exp*'))
latest_run_dir = run_dirs[-1] if run_dirs else None

if latest_run_dir:
    print(f"Latest run directory: {latest_run_dir}")
    # Your code to handle the images with bounding boxes

This will give you the path to the latest predictXX directory, where you can find the saved images with bounding boxes. 📁✨

[jeffrey-cochran]

@glenn-jocher thanks for being so responsive and helpful. It's really impressive. My question is:

What color does yolov8 use as infill when a training image not square?

Maybe I'm misunderstanding, but if the algorithm pads the image to a square size, I'm just curious what color it pads with (zeros, i.e., black?). If it makes any difference, I'm currently training a classification model.

[glenn-jocher]

@jeffrey-cochran hey there! 👋

Great question! When YOLOv8 pads non-square training images to make them square, it uses a padding color of zeros, which is essentially black. This padding ensures that the aspect ratio of the original image is maintained without distortion.

For a classification model, the padding color typically doesn't impact the training process since the focus is on the subject within the image boundaries. However, if you have specific requirements or wish to use a different padding color, you can modify the dataset loading code accordingly.

Happy training, and if you have any more questions or need further assistance, feel free to ask! 😊

[vrtteja001]

Is it possible to combine two YOLOv8 weights?

[glenn-jocher]

Combining two YOLOv8 weights directly isn't a standard feature, but you can average the weights of two models if they have the exact same architecture. Here's a simplified example in Python:

import torch

# Load the state dicts of your two models
weights1 = torch.load('path_to_first_weights.pt')['model'].state_dict()
weights2 = torch.load('path_to_second_weights.pt')['model'].state_dict()

# Average the weights
averaged_weights = {key: (weights1[key] + weights2[key]) / 2 for key in weights1.keys()}

# Load averaged weights back into model
model = torch.load('path_to_model_architecture.pt')['model']
model.load_state_dict(averaged_weights)
torch.save(model.state_dict(), 'path_to_save_averaged_weights.pt')

Remember to replace the paths with your actual file paths. This method is experimental and may not always produce optimal results, so it's important to validate the performance of the combined model. If you have further questions or need assistance, feel free to ask! 😊

[agota-f]

Hello, I have a question regarding the seed and possibly the deterministic parameters. I understand that the seed is set to a value in order to ensure reproducibility. However, if I want to introduce randomness, how can I remove this feature? I understand that seed only accepts a number as a value (or a boolean, as it is also considered 0 or 1), but how can I turn this feature off? Should I set deterministic = False, or give a random number to seed, or both?

[pderrenger]

@agota-f hi there! 👋

Great question! If you're looking to introduce randomness into your training process, you can indeed set deterministic=False. This will allow for non-deterministic operations that can introduce randomness. As for the seed, you don't need to set it if you want to embrace the inherent randomness of training, as it defaults to None which is effectively random.

Here's a quick example of how you might configure this in your training script:

from ultralytics import YOLO

# Load your model
model = YOLO('yolov8n.yaml')

# Train with non-deterministic operations for randomness
model.train(data='coco128.yaml', epochs=3, deterministic=False)

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

[agota-f]

Thank you for your quick answer. I have a question though. According to both the documentation and the code def init_seeds(seed=0, deterministic=False) in ultralytics>utils>torch_utils.py, seed is initialised by default to 0. I tried forcefully to give null for seed in the args file (model.train(..., cfg="./args.yaml")) or None as a training parameter (model.train(..., seed=None)), but it fails at init_seeds(self.args.seed + 1 + RANK, deterministic=self.args.deterministic) in ultralytics>engine>trainer.py>BaseTrainer, as it should, as None is not a number.

Could you please give more clarification on the seed parameter, how it should be initialised if I would like to introduce randomness? Thank you very much!

[glenn-jocher]

@agota-f hey there! 👋

Thanks for reaching out with your question about the seed parameter. You're correct that the default seed is set to 0 to ensure reproducibility. If you're looking to introduce randomness, you don't need to set the seed at all, as each run will inherently have some randomness due to factors like thread scheduling and hardware differences.

However, if you want to explicitly avoid a fixed seed, you can pass a random number to the seed parameter each time you start a training session. Here's a quick example using Python's random library to generate a random seed:

import random
from ultralytics import YOLO

# Generate a random seed
random_seed = random.randint(0, 1000000)

# Load your model
model = YOLO('yolov8n.yaml')

# Train with a random seed
model.train(data='coco128.yaml', epochs=3, seed=random_seed)

This way, you'll get a different seed for each training run, introducing more randomness into the process. Hope this clarifies things! Let me know if you have any more questions. 😊

Happy training! 🚀

[J0ELh]

Hello, I was wondering if you could give me some clarification on the freeze parameter for yolov8. When training begins, the training script automatically prints the layers of the model. There seem to be 23 blocks but over 100 different components. In your examples, you always use freeze = 10. Will this freeze the first 10 blocks or the first 10 components in the model?

In my personal training I used freeze = 135 since when I print the model, all layers before 135 are the backbone, and all layers after are the head. Was this correct, or am I making a mistake?

[glenn-jocher]

@J0ELh hello! Great question regarding the freeze parameter. When you specify freeze=10, it will indeed freeze the first 10 components (layers) of the model, not the blocks. Your approach of using freeze=135 to freeze all layers before 135, which constitute the backbone, is correct if you want to train only the head of the model. This is a common practice when fine-tuning a model on a new dataset while keeping the learned features from the backbone intact.

If you need to verify which layers are frozen, you can check the printed model layers during training, as you've done. Just ensure that the layers you intend to freeze align with the components listed. If you need further clarification or assistance, feel free to ask. Happy training! 😊👍

[J0ELh]

Hello @glenn-jocher, thank you so much for helping. I'm still a bit confused. The official ultralytics documentation (https://docs.ultralytics.com/yolov5/tutorials/transfer_learning_with_frozen_layers/?h=freeze#freeze-backbone) seems to be saying the exact opposite. Here, it seems that if I had indicated freeze = 135 it would have frozen all blocks instead of the individual layers up to 135. I know this documentation is for yolov5 instead of yolov8 but I assumed this behavior stayed the same across versions. Could you please confirm which of the two is correct? In other words, if I use yolov5, and i set freeze = 10, will it freeze the first 10 blocks or the first 10 layers? Same thing for yolov8: will it freeze the first 10 blocks or the first 10 layers?

Thank you for clarifying!

[J0ELh]

I did some testing and it seems like for yolov8 at least, the documentation is correct. Setting Freeze = 10 does freeze the first 9 blocks instead of just the first 10 layers.

[glenn-jocher]

Hey there! 👋

Thanks for doing some testing and sharing your findings! You're correct, in YOLOv8, setting freeze=10 indeed freezes the first 9 blocks. This behavior aligns with the Ultralytics documentation you've referenced.

For YOLOv5, the same principle applies: freeze=10 would freeze the first 10 blocks, not just the individual layers. This consistency across versions helps maintain a uniform user experience.

If you have any more questions or need further assistance, feel free to drop a comment. Happy coding! 😊🚀

[ArfazDS]

i was using YOLOv8 for number detection ( meter readings ), it worked pretty good. but i need small help.
I used this command 'save_txt' to save the labels in a text file. but in the text file the results are saved in accordance to the confidence score. High confidence score labels are saved first due o which the readings are coming wrong. i want to save them in the order in which it is detected in the image. How to do it? Please help

[glenn-jocher]

Hey there! 😊

You're welcome! If you have any more questions or need further assistance, don't hesitate to check out our Help page for a wealth of resources. And of course, if you can't find what you're looking for, feel free to drop us a question on GitHub Issues. Happy coding! 🚀

[neemaaditi]

Hi, I have been successfully executed the steps for Yolov8 model prediction. I am facing an issue with my dataset training, i have some analog meters where there are numbers in decimal that are printed in different colors or have different background colors like red or white but no point denotated in the meter. How do i train such images to detect "." notation to predict decimal since I want to see "." in my actual output of the meter readings

[glenn-jocher]

Hello!

Great to hear that you've successfully executed the YOLOv8 model predictions! Regarding training your model to detect decimal points in analog meters with varying background colors, you might consider a few approaches:

1. Data Annotation: Ensure that your training dataset includes images where the decimal points are clearly annotated, even if they're not physically present on the meter. You can use a symbolic representation (like a dot or special marker) in the exact position where the decimal would logically appear.

2. Data Augmentation: Use data augmentation techniques that might help the model generalize better across different backgrounds and colors. This could include color space transformations, adding noise, or artificially altering the background of the numbers in your training images.

3. Focused Training: You might also train a secondary model specifically to recognize the presence of a decimal point if integrating it into your main model proves challenging.

For implementing these suggestions effectively, ensure your annotations and model adjustments are precise and test frequently with validation data that reflects the real-world usage as closely as possible.

If you need more detailed guidance or run into specific issues, feel free to reach out. Happy coding! 🚀

[neemaaditi]

So, for my above query, I had used an approach where I have annotated the 1st decimal number as follows: .0==10, .1==11, .2==12,...., .9==19 and used a logic to denote these numbers from (10 to 19) as decimals. Although, I'm getting results by this logic the accuracy is not great. How do I improve the accuracy of the model?

[glenn-jocher]

Hi there! 😊

Thank you for sharing your approach and the results you've achieved so far. It's great to see your innovative method for handling decimal points. To help improve the accuracy of your model, here are a few suggestions:

1. Enhanced Data Annotation:

   • Ensure that your annotations are as precise as possible. Consider annotating more examples of decimal points in various contexts and backgrounds to help the model generalize better.
   • If possible, include synthetic data where decimal points are explicitly marked. This can help the model learn to recognize the concept of decimal points more robustly.

2. Data Augmentation:

   • Use data augmentation techniques to introduce variability in your training data. This can include changes in brightness, contrast, color, and background alterations. Augmentation can help the model become more resilient to different visual conditions.

3. Model Architecture and Hyperparameters:

   • Experiment with different model architectures or fine-tune the existing one. Sometimes, a more complex model or a model with different layers can capture the nuances better.
   • Adjust hyperparameters such as learning rate, batch size, and number of epochs. Fine-tuning these parameters can lead to better performance.

4. Transfer Learning:

   • Utilize transfer learning by starting with a pre-trained model and fine-tuning it on your specific dataset. Pre-trained models have already learned a lot of useful features that can be beneficial for your task.

5. Evaluation and Feedback:

   • Continuously evaluate the model's performance on a validation set that closely resembles your test conditions. Use metrics like precision, recall, and F1-score to get a comprehensive understanding of the model's performance.
   • Implement a feedback loop where you iteratively improve the dataset and model based on the evaluation results.

Here's a small code snippet to illustrate data augmentation using the Albumentations library:

import albumentations as A
from albumentations.pytorch import ToTensorV2

transform = A.Compose([
    A.RandomBrightnessContrast(p=0.2),
    A.HueSaturationValue(p=0.2),
    A.RGBShift(p=0.2),
    A.RandomResizedCrop(height=640, width=640, scale=(0.8, 1.0), p=0.5),
    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
    ToTensorV2()
])

# Apply the transform to your dataset

If you haven't already, please ensure you're using the latest versions of torch and ultralytics packages. You can update them using:

pip install --upgrade torch ultralytics

For more detailed guidance, you can refer to our Minimum Reproducible Example (MRE) Guide. This will help us better understand and reproduce any specific issues you might be facing.

Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

[arabinda90]

Dear community thank you to each of the members

I want to extract the tree crown boundary using the Yolo8 model. After training the model when I predict the RGB image each tree has multiple polygons but it should be a single polygon for a tree. Have you any idea how to address this issue?

[glenn-jocher]

Hello! 👋

Great to hear you're using YOLOv8 for tree crown boundary extraction. If you're getting multiple polygons per tree, it might be due to overlapping detections. Here's a quick suggestion:

You can try adjusting the Non-Maximum Suppression (NMS) threshold to reduce overlapping detections. A higher NMS threshold will merge more detections that overlap. You can set this when using the predict method, like so:

results = model.predict(source='image.jpg', iou=0.6)  # Adjust the iou value as needed

Also, ensure that during training, your dataset annotations are as accurate as possible, with one bounding box per tree crown.

If you need more detailed help, feel free to share your code or results on our GitHub Issues, and we'll be happy to assist! 🌳

Happy detecting!

[ArfazDS]

in my YAML file i have 11 labels, with their respective values. But when I use save_txt command the labels are saved in a text file, but i want the exact values to be saved, because label 10 has value ".", which is important for meter reading value. How can I save the values in text file rather than labels. Below is my YAML file:

names:
0: 0
1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: .

[glenn-jocher]

Hey there! 👋 It looks like you want to save the actual class names (like the period '.') instead of the class indices in your text files. To achieve this, you can modify the code that writes to the text file to use the names list from your YAML file as a lookup table. Here's a quick example of how you might do that in Python:

# Assuming 'pred' is your list of predictions and 'names' is from your YAML
with open('output.txt', 'w') as f:
    for p in pred:
        # Get the class index (replace this with your actual prediction index)
        class_index = int(p[5])
        # Write the class name instead of the index
        f.write(f'{names[class_index]}\n')

This snippet assumes pred is a list of predictions where each prediction p has the class index at position 5. Replace this with the actual structure of your predictions. The names should be the list of class names from your YAML file. This way, you'll get the actual class names, like '.', in your text file. Hope this helps! 😊

[J0ELh]

I have not found any resolution to the following issue with yolov8. Whenever I start training my model, the val-set score is immediately 1 for Precision and Recall. I believe this is an error. Therefore, it's really hard to monitor training. Here's an example:

[J0ELh]

The following code should train a model, save the weights, load the weights, and then make a prediction and draw the boxes around the prediction.

import os
import shutil
import random
from PIL import Image

import matplotlib.pyplot as plt
import matplotlib.patches as patches
from tqdm import tqdm
import torch


if __name__ == "__main__":

    model = YOLO('yolov8n.pt')

    model.train(
        data="./data/symbol_classifier.yml", 
        epochs=1, 
        project= "experiment_P_and_R", 
        batch = 10,
        workers = 5, 
        fraction = 0.01,
        save_period = 1,
        save_hybrid = True,
        plots = True,
        exist_ok = True
        )
    
    model = YOLO(r".\experiment_P_and_R\train\weights\last.pt")
    

    results = model.predict(r".\data\val\images\13.png")
    image = Image.open(r".\data\val\images\13.png")
    im_width, im_height = image.size

    # Create a figure and axis for the image
    fig, ax = plt.subplots(1)
    ax.imshow(image, cmap='gray')

    # Assuming results structure here. Adjust as per actual output
    boxes = results[0].boxes.data.cpu().numpy()

    for box in boxes:
        print(box)
        cl, x_center, y_center, width, height, conf = box  # Use box directly if it's already a sequence
        rect_x = (x_center - width / 2) * im_width
        rect_y = (y_center - height / 2) * im_height
        rect_width = width * im_width
        rect_height = height * im_height

        rect = patches.Rectangle((rect_x, rect_y), rect_width, rect_height, linewidth=1, edgecolor='r', facecolor='none')

        # Add the rectangle to the Axes
        ax.add_patch(rect)

    # Generate a unique filename using the counter
    filename = f"pred_images/0.png"
    plt.savefig(filename)
    plt.clf()  # Clear the current figure```

Here's the output I get: 

First of all, the validation score is 1 immediately for Precision and Recall:
```Starting training for 1 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
        1/1      2.86G      1.913      6.557      1.408        295        640: 100%|██████████| 5/5 [00:02<00:00,  2.44it/s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 5/5 [00:02<00:00 
                   all        100       1833          1          1      0.995      0.995

1 epochs completed in 0.003 hours.```

The next issue are the outputs. The training and validation outputs that are automatically saved (val_batch0_labels.png and val_batch0_pred.png) both are completely identical with the pred image having 100% confidence for all predictions. However, pred_images/0.png, returns zero bounding boxes for the sample image. 

Things to note:
- the sample image is from the same distribution as the validation images
- P and R immediately being 1 has been observed on multiple different computers so the issue must be due to the code, not the machine
- the same dataset when trained on yolov5 shows the normal process of first having low val P and R scores, and then improving over time

[glenn-jocher]

It seems you are not understanding the arguments you are passing. You've set save_hybrid = True which integrates the labels with the predictions with the intention of creating hybrid labels. This will cause near-perfect mAP as the labels are now included with your predictions.

[wkdwldnd7487]

I want to load model before doing prediction. model.load_state_dict(torch.load(opt.saved_model, map_location=device)) like this one. I want load model when I run file right after. now i'm using custom yolov8 model.

[glenn-jocher]

Hey there! 👋 The initial longer inference time you're seeing is likely due to model loading and initialization processes, which only occur once. After the first image, these resources are already loaded, hence the faster inference times for subsequent images.

To reduce the initial load time, you could try warming up the model by running a few dummy inferences before processing actual images. Here's a quick example:

# Warm-up
for _ in range(5):
    model.predict(torch.zeros(1, 3, 640, 640))

# Now run on actual data
results = model.predict(rotated_image, conf=0.3, iou=0.3)

This can help to compile and cache necessary operations, potentially speeding up the first real inference. Hope this helps! 😊🚀

[wkdwldnd7487]

Thanks!! That was what I really need..!!

[glenn-jocher]

@wkdwldnd7487 you're welcome! I'm thrilled to hear that the information was exactly what you needed. 😊 If you have any more questions or need further assistance as you work with YOLOv8, don't hesitate to reach out. Happy coding! 🚀

[wkdwldnd7487]

Hi sir. I know this question will be not related with yolo but I don't know where to ask this one. I'm trying to make multi processing with my trained pytorch model. And the problem is when I make other process it always re load the model. It takes more time and gpu memory. Is there any way to share loaded model for the other processes?

[glenn-jocher]

Hey there! 👋 Sharing a loaded PyTorch model across multiple processes can indeed be a bit tricky due to the way each process handles its own memory space. However, you can use PyTorch's multiprocessing module, which provides a share_memory_() method for Tensors. This allows the model's parameters to be shared across processes, potentially saving on loading time and GPU memory.

Here's a quick example of how you might set it up:

from torch.multiprocessing import Process, set_start_method
from your_model_file import YourModel  # make sure to import your model correctly

def worker(model):
    # Your code to use the model here
    pass

if __name__ == '__main__':
    set_start_method('spawn')  # 'spawn' or 'forkserver' start method recommended for CUDA

    # Load your model and share memory
    model = YourModel().cuda()
    model.share_memory()

    # Create processes
    processes = []
    for rank in range(num_processes):
        p = Process(target=worker, args=(model,))
        p.start()
        processes.append(p)

    for p in processes:
        p.join()

Remember to replace YourModel with your actual model class and your_model_file with the file where your model class is defined. Also, adjust num_processes to the number of processes you want to run.

Hope this helps you streamline your multiprocessing setup! If you need more detailed guidance, feel free to check out our FAQ or ask on our GitHub Issues. Happy coding! 😄👨‍💻

[Pragyy-G]

Hi Guys at ultralytics
I am trying to train the YOLOv8 Detect model however, I am after searching thoroughly not able to find if the training could be stopped at minimum validation loss
Is there a way like this to do for YOLOv8

{ Still, there's the general route of training using defining everything as torch variables and then have a training loop
However, I am looking for a faster way for that if there's something which could be done using Yolo Train mode itself}

[glenn-jocher]

Hello! 👋

Great question! YOLOv8's training process includes an early stopping mechanism that halts training if the validation loss does not improve for a specified number of epochs. This is controlled by the patience argument in the training command. By default, it's set to 50 epochs, but you can adjust it to your preference.

For example, to stop training after 10 epochs without improvement in validation loss, you can use:

yolo detect train data=your_dataset.yaml model=yolov8n.pt epochs=100 patience=10

This way, you can leverage the built-in functionality of YOLO Train mode without needing to manually monitor the validation loss. Let me know if you need further assistance! 😊

Happy training!

[menibl]

hello
i train my own model (gate.pt) and i want to use it at the same time with yolov8n.pt
my application need to detect a persone and a gate the persone is coming from yolov8n.pt and the gate from gate.pt
can i run them at the same time ?
thank you

[glenn-jocher]

@menibl hello! 😊

Yes, you can run two models simultaneously to detect different objects. You'll need to load both models and perform inference with each on your images or video stream. Here's a small code snippet to get you started:

from ultralytics import YOLO

# Load your custom gate model and the YOLOv8n model
model_gate = YOLO('path/to/gate.pt')
model_person = YOLO('yolov8n.pt')

# Run inference with both models
results_gate = model_gate.predict('path/to/image_or_video')
results_person = model_person.predict('path/to/image_or_video')

# Now you can process the results from both models

Make sure to replace 'path/to/image_or_video' with the actual path to your data. If you're processing video, you might want to loop over the frames and run predictions frame by frame.

If you need further assistance or have more questions, feel free to ask. Happy detecting! 🚀

For more detailed guides, check out our help documentation.

[viveksharma697]

i have trained the YOLOv8n with a deck of cards, it was detecting most of the cards well but there was confusion with the similar cards such as 5 and 3 etc. So i tried to fine tune that best.pt model by providing the data sets of cards 5 and 3 only but now it only detects 5 and 3 not the other cards. I have a lot of deck of cards to train and i want to have only one model to detect them. So how can i do that...I have already tried to retrain that best.pt but it forgets the previously trained deck...So how can i do that because i do not found any appropriate answer in the official website. Is it possible, if yes then how...Reply as soon as possible...

[pderrenger]

Hey there! 👋 It sounds like you're encountering a common challenge in machine learning known as "catastrophic forgetting," where the model forgets previously learned information upon learning new data. To address this for your deck of cards, you might want to consider incremental learning or fine-tuning in a way that includes both new and old data. Here's a quick suggestion:

1. Combine Datasets: Merge your new dataset (cards 5 and 3) with a subset of the original dataset. This combined dataset should include examples of all card types you want the model to recognize.
2. Fine-Tune: Use this combined dataset to fine-tune your best.pt model. This approach helps the model maintain its ability to recognize previously trained cards while improving its accuracy on the cards it was confusing.

Here's a simple example of how you might proceed with the training command:

yolo train data=combined_dataset.yaml model=path/to/best.pt epochs=50

Ensure your combined_dataset.yaml points to the merged dataset. This method helps in retaining the knowledge of the old cards while improving on the specific ones you're interested in.

If you're still facing issues or have more questions, feel free to reach out. We're here to help! 🚀

[viveksharma697]

Thank you so much for your suggestions, I have 10 decks of english cards and you are saying that I should combined all the datasets of these decks , and then train it again. I think it will take a lot of time ...nearly 13-14 days for training if I want to add the datasets of new deck of cards everytime. There must be a better way than that...I am beginner to YOLO so please help me.

[pderrenger]

@viveksharma697 hey there! 🌟 I totally understand your concern about the time it takes to train on multiple decks of cards. A more efficient approach might be to use a technique called "transfer learning." This way, you can start with your already trained model (best.pt) and continue training on your new deck without starting from scratch each time. Here's a quick example:

yolo train data=new_deck.yaml model=path/to/best.pt epochs=10

Make sure new_deck.yaml includes your new deck data along with a mix of the old data. This method can significantly reduce training time while still improving your model's performance across all decks.

If you're adding decks frequently, consider automating the process of combining datasets or incrementally adding new data to your training set. This way, you're always building on what the model has learned without overwhelming it with too much new information at once. 🚀

Hope this helps! If you have more questions, feel free to ask. Happy training!

[viveksharma697]

ok...thank you so much for your reply. This is the content in my data.yaml:
train: ../train/images
val: ../valid/images
test: ../test/images
nc: 52
names: ['Ah','Kh','Qh','Jh','10h','9h','8h','7h','6h','5h','4h','3h','2h','Ad','Kd','Qd','Jd','10d','9d','8d','7d','6d','5d','4d','3d','2d','Ac','Kc','Qc','Jc','10c','9c','8c','7c','6c','5c','4c','3c','2c','As','Ks','Qs','Js','10s','9s','8s','7s','6s','5s','4s','3s','2s']

So, please help me what should I change here as my classes will be same everytime and just those images and .txt files will change in same folder for new decks. But the time of training always keeps on increasing if I add new images to these folders and then start the training of previously trained best.pt.
So, what am I doing wrong...? Please help me.

[pderrenger]

Hey there! 👋 It looks like your data.yaml setup is correct for handling different decks as long as the class names (nc and names) remain consistent across your datasets. If you're finding that training time increases with each new set of images, it's likely due to the growing dataset size.

One approach to manage training time while still improving your model is to selectively add new images. Instead of adding all images from new decks, you could add a representative subset that includes the most challenging or diverse examples. This way, you're enriching the dataset without overly increasing its size.

Another tip is to ensure your training process is as efficient as possible. For instance, using a GPU if you're not already can significantly speed up training times. Also, adjusting training parameters like batch size and image size can help find a balance between speed and accuracy.

Here's a quick example of how to continue training with your best.pt model:

yolo train data=data.yaml model=path/to/best.pt epochs=10

This command assumes you're adding new images to the folders specified in data.yaml and want to continue training your model to recognize these new images without forgetting the old ones.

Remember, it's all about finding the right balance for your specific needs. Hope this helps! If you have more questions, feel free to ask. Happy training! 🚀

[vamshigaddi]

Hello,
I am having trouble with object counting. I have been using this method to count the number of people entering and leaving the cafe. However, the counts are showing up in reverse. For example, when a person enters the cafe, it shows as out_count, and when a person leaves the cafe, it shows as in_count. I have tried to fix this issue on my own, but I have been unsuccessful. Can you help me with the code to correct this?

[glenn-jocher]

@vamshigaddi hello,

Thank you for reaching out! It sounds like you're encountering an issue with the directionality of your object counting logic. To assist you better, could you please provide a minimum reproducible example of your code? This will help us understand the exact setup and logic you're using. You can find more details on creating a minimum reproducible example here: Minimum Reproducible Example Guide.

Additionally, please ensure that you are using the latest versions of torch and ultralytics. Sometimes, bugs are fixed in newer releases, and updating might resolve your issue. You can update your packages using the following commands:

pip install --upgrade torch
pip install --upgrade ultralytics

Once you provide the code and confirm the versions, we can dive deeper into the issue. Looking forward to your response!

[vamshigaddi]

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("/content/6641527-hd_1920_1080_30fps.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

Define line points

#line_points = [(673, 408),(921, 824)]
line_points = [(631, 314),(631, 832),(786, 905),(786, 286)]

Video writer

video_writer = cv2.VideoWriter("object_counting_output_t1.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

Init Object Counter

counter = solutions.ObjectCounter(
view_img=True,
reg_pts=line_points,
classes_names=model.names,
draw_tracks=True,
line_thickness=2,
)

while cap.isOpened():
success, im0 = cap.read()
if not success:
print("Video frame is empty or video processing has been successfully completed.")
break
tracks = model.track(im0, persist=True, show=False,classes=[0])

im0 = counter.start_counting(im0, tracks)
video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

[vamshigaddi]

This code displays out_count when people entering into cafe and displays in_count ,when they are living cafe.

[glenn-jocher]

Hi @vamshigaddi,

Thank you for providing your code example! It helps us understand the issue better. It seems like the counts are reversed when people enter and leave the cafe. Let's address this.

The ObjectCounter class uses the defined region or line points to determine the direction of movement. If the counts are reversed, it might be due to the orientation of your defined region points.

Here's a revised version of your code with a focus on ensuring the region points are correctly oriented. You can adjust the points to match the actual entry and exit directions:

import cv2
from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")
cap = cv2.VideoCapture("/content/6641527-hd_1920_1080_30fps.mp4")
assert cap.isOpened(), "Error reading video file"
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))

# Define line points (adjust these points to match the entry and exit directions)
line_points = [(631, 314), (631, 832), (786, 905), (786, 286)]

# Video writer
video_writer = cv2.VideoWriter("object_counting_output_t1.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init Object Counter
counter = solutions.ObjectCounter(
    view_img=True,
    reg_pts=line_points,
    classes_names=model.names,
    draw_tracks=True,
    line_thickness=2,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False, classes=[0])

    im0 = counter.start_counting(im0, tracks)
    video_writer.write(im0)

cap.release()
video_writer.release()
cv2.destroyAllWindows()

Key Points:

1. Region Points Orientation: Ensure the line_points are correctly oriented to match the entry and exit directions.
2. Classes: You are filtering for class 0 (person). Ensure this matches your use case.

If the issue persists, please verify that you are using the latest versions of torch and ultralytics:

pip install --upgrade torch
pip install --upgrade ultralytics

For further details on object counting, you can refer to our Object Counting Guide.

Feel free to adjust the region points and let us know if this resolves the issue. We're here to help! 😊

[swarnalathayv]

Thank you for your response. It is working now😊

…

On Wed, 19 Jun, 2024, 3:26 pm Glenn Jocher, ***@***.***> wrote: @swarnalathayv <https://github.com/swarnalathayv> hi Swarnalatha, Thank you for reaching out! 😊 It sounds like you're encountering an environment issue where Jupyter Notebook isn't recognizing the torch module, while it works fine in IDLE. Let's troubleshoot this step-by-step: 1. *Verify CUDA Installation*: Ensure that CUDA is correctly installed by running: nvcc --version This should display the CUDA version installed on your system. 2. *Check PyTorch Installation*: Make sure PyTorch is installed in the same environment that Jupyter Notebook is using. You can verify this by running: import torchprint(torch.cuda.is_available())print(torch.cuda.get_device_name(0)) This should return True and the name of your GPU if everything is set up correctly. 3. *Update Packages*: Ensure you are using the latest versions of torch and ultralytics. You can update them using: pip install --upgrade torch ultralytics 4. *Check Jupyter Kernel Environment*: Ensure that your Jupyter Notebook kernel is running in the same environment where CUDA and PyTorch are installed. You can check this by running: !which python This should point to the Python executable in your environment with CUDA and PyTorch. 5. *Set the Device in Your Training Script*: Explicitly set the device to GPU in your training script. Here’s an example: from ultralytics import YOLO # Load the modelmodel = YOLO('yolov8n.pt') # Set up training argumentsargs = { 'data': 'path/to/your_data.yaml', 'epochs': 100, 'batch': 12, 'imgsz': 640, 'device': 'cuda' # Ensure the model uses the GPU } # Train the modelresults = model.train(**args) If the issue persists, please provide a minimum reproducible example (MRE) of your code so we can better assist you. You can find more details on creating an MRE here <https://docs.ultralytics.com/help/minimum_reproducible_example>. Feel free to reach out if you need further assistance. We're here to help! 🚀 — Reply to this email directly, view it on GitHub <#8027 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A6BY3KGTN2V6FUMZ77GE3VDZIFIUNAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMJVG4YDC> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

@swarnalathayv hi Swarnalatha,

Thank you for the update! I'm glad to hear that everything is working now 😊.

If you encounter any further issues or have additional questions, please don't hesitate to reach out. For more detailed guides and resources, you can always visit our Help Page.

Happy coding! 🚀

[swarnalathayv]

How to do preprocessing of Images. Like filtering, enhancing and mirroring etc.,

[pderrenger]

Hi there,

Thank you for your question! To preprocess images for tasks like filtering, enhancing, and mirroring, you can utilize various libraries in Python such as OpenCV, PIL, and even built-in functionalities within the Ultralytics YOLO framework.

Here's a quick example using OpenCV for some common preprocessing tasks:

import cv2

# Load an image
image = cv2.imread('path/to/your/image.jpg')

# Convert to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply Gaussian Blur
blurred_image = cv2.GaussianBlur(image, (5, 5), 0)

# Enhance image using Histogram Equalization
equalized_image = cv2.equalizeHist(gray_image)

# Mirror the image
mirrored_image = cv2.flip(image, 1)

# Save the processed images
cv2.imwrite('gray_image.jpg', gray_image)
cv2.imwrite('blurred_image.jpg', blurred_image)
cv2.imwrite('equalized_image.jpg', equalized_image)
cv2.imwrite('mirrored_image.jpg', mirrored_image)

For more advanced preprocessing, you might want to explore the Albumentations library, which offers a wide range of augmentation techniques.

If you encounter any issues or need further assistance, please ensure you provide a minimum reproducible example (MRE) as outlined here. This helps us reproduce your issue and provide a more accurate solution.

Feel free to reach out if you have more questions! 😊

[swarnalathayv]

For these images also should i annotate again? Please give code snippet.

[pderrenger]

Hi there,

Thank you for your question! 😊

If you have preprocessed images (e.g., filtered, enhanced, mirrored) and you plan to use them for training or validation, you will indeed need to annotate them again. The annotations must correspond to the new image transformations to ensure accurate training.

Here's a concise code snippet to help you get started with image preprocessing and saving the annotations:

import cv2
import shutil
import os

# Function to copy and rename annotation files
def copy_annotations(src_img, dest_img, src_annot_dir, dest_annot_dir):
    annot_file = os.path.splitext(os.path.basename(src_img))[0] + '.txt'
    src_annot_path = os.path.join(src_annot_dir, annot_file)
    dest_annot_path = os.path.join(dest_annot_dir, os.path.splitext(os.path.basename(dest_img))[0] + '.txt')
    shutil.copy(src_annot_path, dest_annot_path)

# Load an image
image_path = 'path/to/your/image.jpg'
image = cv2.imread(image_path)

# Mirror the image
mirrored_image = cv2.flip(image, 1)

# Save the processed image
processed_image_path = 'path/to/processed_image.jpg'
cv2.imwrite(processed_image_path, mirrored_image)

# Copy and rename the corresponding annotation file
src_annotation_dir = 'path/to/annotations'
dest_annotation_dir = 'path/to/processed_annotations'
copy_annotations(image_path, processed_image_path, src_annotation_dir, dest_annotation_dir)

This script mirrors an image and copies the corresponding annotation file to a new directory. Ensure that the annotations are correctly adjusted for any transformations applied to the images.

For more detailed guidance on creating and managing annotations, please refer to our Minimum Reproducible Example (MRE) Guide.

If you encounter any issues or need further assistance, feel free to reach out. We're here to help! 🚀

[swarnalathayv]

Thanks for your support. After training, the results were saved in the run--detect--train13 folder. All the images given for validation are detected, but all images are arranged in tile format (12 images given for validation, all images converted to single image 4X3 tile format). And I loaded my custom model (best.pt) for testing on the images. Here is the code snippet model = YOLO('best.pt') img = 'test.tif' result = model(img) result.print() But it is showing like print is not in the list. How to display my input image with bounding boxes? Kindly help.

…

On Wed, Jun 19, 2024 at 11:20 PM Paula Derrenger ***@***.***> wrote: @swarnalathayv <https://github.com/swarnalathayv> hi Swarnalatha, Thank you for the update! I'm glad to hear that everything is working now 😊. If you encounter any further issues or have additional questions, please don't hesitate to reach out. For more detailed guides and resources, you can always visit our Help Page <https://docs.ultralytics.com/help/>. Happy coding! 🚀 — Reply to this email directly, view it on GitHub <#8027 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A6BY3KGI4DSLPFJSNQGQVD3ZIHAFNAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMRQGU3DG> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

-- Thanks & Regards Swarnalatha YV Sci/ Eng - SC VSSC, Trivandrum. Ph: 0471-256-4375

[pderrenger]

@swarnalathayv hi Swarnalatha,

Thank you for reaching out and for your support! 😊

To address your issue with displaying the input image with bounding boxes, it seems like there might be a small confusion with the method names. The result.print() method is not available, but you can use the result.show() method to display the image with bounding boxes. Here’s how you can modify your code snippet:

from ultralytics import YOLO

# Load your custom model
model = YOLO('best.pt')

# Specify the image for testing
img = 'test.tif'

# Run the model on the image
result = model(img)

# Display the image with bounding boxes
result.show()

This should display your input image with the detected bounding boxes.

Regarding the arrangement of validation images in a tile format, this is a default behavior for visualizing multiple images together. If you prefer to view them individually, you can save the results and view them separately:

# Save the results to a directory
result.save(save_dir='path/to/save/directory')

This will save each image with bounding boxes in the specified directory.

If you encounter any further issues or have additional questions, please don't hesitate to reach out. For more detailed guides and resources, you can always visit our Help Page.

Happy coding! 🚀

[swarnalathayv]

result.show() it is throwing an error that the list has no object show.

[pderrenger]

Hi @swarnalathayv,

Thank you for your message! It looks like you're encountering an issue with the result.show() method. The error you're seeing suggests that result is a list of Results objects, and you're trying to call show() on the list itself rather than on an individual Results object.

To resolve this, you should call show() on each Results object within the list. Here’s how you can modify your code:

from ultralytics import YOLO

# Load your custom model
model = YOLO('best.pt')

# Specify the image for testing
img = 'test.tif'

# Run the model on the image
results = model(img)

# Display each result with bounding boxes
for result in results:
    result.show()

This will display each image with the detected bounding boxes.

If you continue to experience issues, please ensure that you are using the latest versions of torch and ultralytics. You can upgrade your packages using the following commands:

pip install --upgrade torch ultralytics

If the problem persists, please provide a minimum reproducible example so we can investigate further. You can find more information on creating a minimum reproducible example here.

Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

[Etty-Cohen]

Hi, I try to load and inference yolov8s model in opencv, c++, I faced a bug: the result is seems empty. on exact same image I get full results hen loading with ultralytics in python. my code: DNN* net; Mat blob, prob; *net = readNet("yolov8.onnx"); setNetInputSize("yolov8.onnx"); net->setPreferableBackend(DNN_BACKEND_CUDA); net->setPreferableTarget(DNN_TARGET_CUDA); std::cout << "loading succeeded" << std::endl; blob = blobFromImage(image, 1.0, Size(640, 640), (0,0,0), true); net->setInput(blob); prob = net->forward(); than I try to print the result: std::cout<<"prob.rows="<<prob.rows<<" prob.cols="<<prob.cols<<'\n'; for (int i = 0; i < prob.rows; i++) { for (int j = 0; j < prob.cols; j++) { std::cout << (int)prob.at<uchar>(i, j) << " "; } std::cout << std::endl; } and get: prob.rows=-1 prob.cols=-1 what am I doing wrong? ‫בתאריך יום ה׳, 20 ביוני 2024 ב-12:39 מאת ‪Paula Derrenger‬‏ <‪ ***@***.***‬‏>:‬

…

@swarnalathayv <https://github.com/swarnalathayv> hi Swarnalatha, Thank you for reaching out and for your support! 😊 To address your issue with displaying the input image with bounding boxes, it seems like there might be a small confusion with the method names. The result.print() method is not available, but you can use the result.show() method to display the image with bounding boxes. Here’s how you can modify your code snippet: from ultralytics import YOLO # Load your custom modelmodel = YOLO('best.pt') # Specify the image for testingimg = 'test.tif' # Run the model on the imageresult = model(img) # Display the image with bounding boxesresult.show() This should display your input image with the detected bounding boxes. Regarding the arrangement of validation images in a tile format, this is a default behavior for visualizing multiple images together. If you prefer to view them individually, you can save the results and view them separately: # Save the results to a directoryresult.save(save_dir='path/to/save/directory') This will save each image with bounding boxes in the specified directory. If you encounter any further issues or have additional questions, please don't hesitate to reach out. For more detailed guides and resources, you can always visit our Help Page <https://docs.ultralytics.com/help/>. Happy coding! 🚀 — Reply to this email directly, view it on GitHub <#8027 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AO26URDIUZDVRR77BLDY743ZIKPNDAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMRWHEZDK> . You are receiving this because you were mentioned. Message ID: ***@***.*** com>

-- אתי כהן (א.שאול)

[vamshigaddi]

import cv2
import numpy as np
import torch
from ultralytics import YOLO
from shapely.geometry import Polygon, box
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import smtplib

Email settings

password = "" # Your email password
from_email = "" # Your email address
to_email = "" # Receiver's email address

server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)

def send_email(to_email, from_email, object_detected=1):
"""Sends an email notification indicating the number of objects detected; defaults to 1 object."""
message = MIMEMultipart()
message["From"] = from_email
message["To"] = to_email
message["Subject"] = "Security Alert"
message_body = f"ALERT - {object_detected} objects have been detected crossing the boundary!!"
message.attach(MIMEText(message_body, "plain"))
server.sendmail(from_email, to_email, message.as_string())

class ObjectDetection:
def init(self, capture_index, region_points, output_video_path):
"""Initializes an ObjectDetection instance with a given camera index."""
self.capture_index = capture_index
self.region_points = region_points
self.email_sent = False
self.output_video_path = output_video_path

    # Model information
    self.model = YOLO("yolov8n.pt")

    # Device information
    self.device = "cuda" if torch.cuda.is_available() else "cpu"

    # Prepare the region polygon
    self.region_polygon = Polygon(region_points)

def predict(self, im0):
    """Run prediction using a YOLO model for the input image `im0`."""
    results = self.model(im0)
    return results

def check_region_intersection(self, boxes):
    """Check if any detected object intersects with the specified region."""
    crossed_boxes = []
    for box_coords in boxes:
        # Extract box coordinates
        x1, y1, x2, y2 = box_coords
        # Define the bounding box as a Shapely box
        bbox = box(x1, y1, x2, y2)

        # Check if the bounding box intersects with the region polygon
        if self.region_polygon.intersects(bbox):
            crossed_boxes.append(box_coords)

    return crossed_boxes

def __call__(self):
    """Executes object detection on video frames from a specified camera index and triggers alerts if objects intersect with the region."""
    cap = cv2.VideoCapture(self.capture_index)
    assert cap.isOpened()
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
    fps = cap.get(cv2.CAP_PROP_FPS)
    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # Define the codec and create VideoWriter object
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(self.output_video_path, fourcc, fps, (frame_width, frame_height))

    while True:
        ret, im0 = cap.read()
        if not ret:
            print("Failed to read frame. Exiting...")
            break

        results = self.predict(im0)

        class_ids = results[0].boxes.cls.cpu().numpy().astype(int)
        boxes = results[0].boxes.xyxy.cpu().numpy().astype(int)

        crossed_boxes = self.check_region_intersection(boxes)

        if crossed_boxes:
            if not self.email_sent:
                send_email(to_email, from_email, len(crossed_boxes))
                self.email_sent = True
        else:
            self.email_sent = False

        # Annotate the frame
        for box, cls in zip(boxes, class_ids):
            # Use red color for crossed objects
            if any(np.array_equal(box, crossed_box) for crossed_box in crossed_boxes):
                color = (0, 0, 255)
            else:
                # YOLO default colors
                color = (int(cls * 37 % 255), int(cls * 17 % 255), int(cls * 47 % 255))

            class_name = self.model.names[cls]  # Get the class name using model.names
            label = f"{class_name}"

            cv2.rectangle(im0, (box[0], box[1]), (box[2], box[3]), color, 2)
            cv2.putText(im0, label, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

        # Write the annotated frame to the output video
        out.write(im0)

    # Release everything if job is finished
    cap.release()
    out.release()
    cv2.destroyAllWindows()
    server.quit()

Usage

#region_points = [(51, 832), (287, 820), (567, 452), (159, 428)]
region_points = [(31, 838),(299, 774),(531, 466),(167, 430)] # Example region points
output_video_path = "output_video.mp4" # Specify the path where you want to save the output video
detector = ObjectDetection(capture_index='/content/5930933-hd_1280_720_30fps (online-video-cutter.com).mp4', region_points=region_points, output_video_path=output_video_path)
detector()

Hello Glen , Iam working on trepassing project, My goal is to detect the object that touched or entered into into that region, iam getting alerts when object detected and iam not able to change the color of bounding boxes of the detected objects to red , when they crossed or touched the region , i have mentioned.
My goal is to change the detected objects bouning boxes to red and all the objects that are away from region are in unique color boudning boxes and also the snapshots of objects detected should be sent to the email and save the output video.

can you help me with the adjusting the code

[glenn-jocher]

@vamshigaddi hello,

Thank you for sharing your code and explaining your project goals. It sounds like you're working on an interesting trespassing detection system! Let's address your requirements step by step:

1. Changing Bounding Box Colors: To change the color of bounding boxes to red when objects cross the specified region and use unique colors for other objects, you can modify the annotation part of your code.

2. Sending Snapshots via Email: To send snapshots of detected objects via email, you can capture the frame when an object crosses the region and attach it to the email.

3. Saving the Output Video: Your current implementation already saves the output video, so no changes are needed there.

Here is the updated code with the necessary adjustments:

import cv2
import numpy as np
import torch
from ultralytics import YOLO
from shapely.geometry import Polygon, box
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
import smtplib

# Email settings
password = ""  # Your email password
from_email = ""  # Your email address
to_email = ""  # Receiver's email address

server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)

def send_email(to_email, from_email, object_detected=1, image_path=None):
    """Sends an email notification indicating the number of objects detected; defaults to 1 object."""
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    message_body = f"ALERT - {object_detected} objects have been detected crossing the boundary!!"
    message.attach(MIMEText(message_body, "plain"))
    
    if image_path:
        with open(image_path, 'rb') as img:
            img_data = img.read()
        image = MIMEImage(img_data, name="detected_object.png")
        message.attach(image)
    
    server.sendmail(from_email, to_email, message.as_string())

class ObjectDetection:
    def __init__(self, capture_index, region_points, output_video_path):
        """Initializes an ObjectDetection instance with a given camera index."""
        self.capture_index = capture_index
        self.region_points = region_points
        self.email_sent = False
        self.output_video_path = output_video_path

        # Model information
        self.model = YOLO("yolov8n.pt")

        # Device information
        self.device = "cuda" if torch.cuda.is_available() else "cpu"

        # Prepare the region polygon
        self.region_polygon = Polygon(region_points)

    def predict(self, im0):
        """Run prediction using a YOLO model for the input image `im0`."""
        results = self.model(im0)
        return results

    def check_region_intersection(self, boxes):
        """Check if any detected object intersects with the specified region."""
        crossed_boxes = []
        for box_coords in boxes:
            # Extract box coordinates
            x1, y1, x2, y2 = box_coords
            # Define the bounding box as a Shapely box
            bbox = box(x1, y1, x2, y2)

            # Check if the bounding box intersects with the region polygon
            if self.region_polygon.intersects(bbox):
                crossed_boxes.append(box_coords)

        return crossed_boxes

    def __call__(self):
        """Executes object detection on video frames from a specified camera index and triggers alerts if objects intersect with the region."""
        cap = cv2.VideoCapture(self.capture_index)
        assert cap.isOpened()
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        fps = cap.get(cv2.CAP_PROP_FPS)
        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

        # Define the codec and create VideoWriter object
        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        out = cv2.VideoWriter(self.output_video_path, fourcc, fps, (frame_width, frame_height))

        while True:
            ret, im0 = cap.read()
            if not ret:
                print("Failed to read frame. Exiting...")
                break

            results = self.predict(im0)

            class_ids = results[0].boxes.cls.cpu().numpy().astype(int)
            boxes = results[0].boxes.xyxy.cpu().numpy().astype(int)

            crossed_boxes = self.check_region_intersection(boxes)

            if crossed_boxes:
                if not self.email_sent:
                    # Save snapshot
                    snapshot_path = "snapshot.png"
                    cv2.imwrite(snapshot_path, im0)
                    send_email(to_email, from_email, len(crossed_boxes), snapshot_path)
                    self.email_sent = True
            else:
                self.email_sent = False

            # Annotate the frame
            for box, cls in zip(boxes, class_ids):
                # Use red color for crossed objects
                if any(np.array_equal(box, crossed_box) for crossed_box in crossed_boxes):
                    color = (0, 0, 255)
                else:
                    # YOLO default colors
                    color = (int(cls * 37 % 255), int(cls * 17 % 255), int(cls * 47 % 255))

                class_name = self.model.names[cls]  # Get the class name using model.names
                label = f"{class_name}"

                cv2.rectangle(im0, (box[0], box[1]), (box[2], box[3]), color, 2)
                cv2.putText(im0, label, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

            # Write the annotated frame to the output video
            out.write(im0)

        # Release everything if job is finished
        cap.release()
        out.release()
        cv2.destroyAllWindows()
        server.quit()

# Usage
region_points = [(31, 838), (299, 774), (531, 466), (167, 430)]  # Example region points
output_video_path = "output_video.mp4"  # Specify the path where you want to save the output video
detector = ObjectDetection(capture_index='/content/5930933-hd_1280_720_30fps (online-video-cutter.com).mp4', region_points=region_points, output_video_path=output_video_path)
detector()

This code will:

• Change the bounding box color to red for objects that cross the specified region.
• Send an email with a snapshot of the detected objects when they cross the region.
• Save the output video with annotated frames.

For further assistance, you can refer to our Security Alarm System Project Guide.

If you encounter any issues, please ensure you are using the latest versions of torch and ultralytics. If the problem persists, please provide a minimum reproducible example as outlined in our MRE Guide.

Happy coding! 😊

[vamshigaddi]

Hey Glenn, I wanted to say thank you. I love you for helping with this Problem and appreciate all the hard work you and your team are putting in. Keep it up and let's make Yolo even more better!

[glenn-jocher]

Hello,

Thank you so much for your kind words and support! The YOLO community and the Ultralytics team truly appreciate it. We're always striving to make YOLO even better, and feedback like yours is incredibly motivating 😊.

If you're encountering any issues or bugs, please ensure you've provided a minimum reproducible example. This helps us understand and reproduce the problem on our end, which is crucial for investigating and resolving it. You can find more details on how to create an MRE here: Minimum Reproducible Example Guide.

Additionally, please make sure you're using the latest versions of torch and ultralytics. If not, upgrading these packages might resolve your issue.

If you have any specific questions or need further assistance, feel free to share more details. We're here to help!

[vamshigaddi]

Hello,
how can I retain the track IDs of objects, even if there is any occlusion? My model assigns new track IDs to the object if it is not visible to the camera for some time . How can I avoid this?

[glenn-jocher]

Hello,

Thank you for reaching out! Retaining track IDs during occlusions can indeed be challenging. Here are a few strategies you can employ to improve the robustness of your tracking:

1. Increase the track_high_thresh and track_low_thresh Values: Adjusting these thresholds in your tracker configuration can help maintain track IDs during brief occlusions. Higher values can make the tracker more resilient to temporary losses of visibility.

2. Use a More Robust Tracker: Some tracking algorithms are better at handling occlusions. For instance, you might want to experiment with different trackers like BoT-SORT or ByteTrack, which are known for their robustness in such scenarios. You can switch trackers by specifying the tracker configuration file, e.g., tracker="bytetrack.yaml".

3. Adjust the max_age Parameter: This parameter controls how long a track is kept without detections. Increasing max_age allows the tracker to retain the track ID for a longer period during occlusions.

Here is an example of how you might adjust these parameters in your code:

from ultralytics import YOLO

# Load the model
model = YOLO("yolov8n.pt")

# Perform tracking with custom tracker settings
results = model.track(source="your_video.mp4", tracker="bytetrack.yaml", track_high_thresh=0.7, track_low_thresh=0.4, max_age=30)

If you continue to experience issues, please ensure you are using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidance on creating an MRE here: Minimum Reproducible Example Guide.

Feel free to share more details if you need further assistance. We're here to help! 😊

[shar486]

Hello, I want to know the information of business license.

[glenn-jocher]

@shar486 hello,

Thank you for your interest in our business license! For commercial use, Ultralytics offers an Enterprise License that allows seamless integration of our software and AI models into commercial products and services without the open-source requirements of the AGPL-3.0 license.

To learn more about the Enterprise License and to apply, please visit our licensing page at Ultralytics Licensing. If you have any specific questions or need further assistance, feel free to reach out through the contact options provided on that page.

[chaichana-t]

Does Oriented Bounding Box Object Detection support annotations using non-rectangular shapes, such as trapezoids or any 4-point polygons? I want to train for License Plate Detection where the license plates are not viewed from the front angle and need to transform the 4 points to a front-facing angle.

[glenn-jocher]

@chaichana-t hello,

Thank you for your question! Yes, Ultralytics YOLO models do support annotations using non-rectangular shapes, such as trapezoids or any 4-point polygons, through the Oriented Bounding Box (OBB) format. This format is particularly useful for scenarios like License Plate Detection where objects are viewed from various angles.

In the YOLO OBB format, bounding boxes are defined by their four corner points with coordinates normalized between 0 and 1. Here’s an example of how an annotation might look in a *.txt label file:

class_index, x1, y1, x2, y2, x3, y3, x4, y4

For instance, an object of class 0 could be annotated as follows:

0 0.780811 0.743961 0.782371 0.74686 0.777691 0.752174 0.776131 0.749758

To train a model using these OBB annotations, you can use the following code snippet:

from ultralytics import YOLO

# Create a new YOLOv8n-OBB model from scratch
model = YOLO("yolov8n-obb.yaml")

# Train the model on your dataset
results = model.train(data="your_dataset.yaml", epochs=100, imgsz=640)

Or via CLI:

yolo detect train data=your_dataset.yaml model=yolov8n.pt epochs=100 imgsz=640

For more detailed information on OBB datasets and how to format your annotations, you can refer to our Oriented Bounding Box (OBB) Datasets Overview.

If you encounter any issues or have further questions, please ensure you are using the latest version of the Ultralytics packages. Additionally, providing a minimum reproducible example can greatly help in diagnosing and resolving any problems you might face. You can find more information on creating an MRE here.

Happy coding! 😊

[chaichana-t]

Thanks a lot! I really appreciate your help and the work you've done.

[glenn-jocher]

Hello @chaichana-t,

Thank you for your kind words! 😊 We're glad to hear that you appreciate our work.

To ensure we can assist you effectively, could you please provide a minimum reproducible example of the issue you're encountering? This will help us diagnose and resolve the problem more efficiently. You can find guidance on creating a reproducible example here.

Additionally, please make sure you are using the latest versions of the Ultralytics packages, as updates often include important bug fixes and improvements.

If you have any further questions or need additional assistance, feel free to ask. We're here to help!

[chaichana-t]

I haven't started training yet. I just want to ensure that this problem can be solved using OBB first. I will then create a dataset and train the model accordingly. If I encounter any issues, I will get back to you. Thanks!

[glenn-jocher]

Hello @chaichana-t,

Thank you for your message! It's great to hear that you're considering using Oriented Bounding Boxes (OBB) for your project. OBB is indeed well-suited for tasks like License Plate Detection, especially when dealing with non-rectangular shapes and varying angles.

To get started, you can refer to the Oriented Bounding Box (OBB) Datasets Overview for detailed information on dataset formats and training procedures. This guide will help you understand how to structure your dataset and annotations correctly.

If you encounter any issues during your training process, please don't hesitate to reach out. When you do, providing a minimum reproducible example will be incredibly helpful for us to diagnose and resolve any problems efficiently. You can find more information on creating an MRE here.

Also, ensure you are using the latest versions of the Ultralytics packages to benefit from the latest features and fixes.

Best of luck with your project, and happy coding! 😊

[BhavyaDedhia]

Hi Ultralytics team,

I'm currently using YOLOv8, which provides a pre-trained .pt model that detects 80 objects. I have a dataset containing new objects that I want to add to this model, but I do not have the dataset for the original 80 objects.

Could you please guide me on how to add these new objects to the existing YOLOv8 model? What is the best approach to fine-tune the model so that it can detect both the original 80 classes and the new classes? Additionally, do I need the dataset for the original 80 classes to successfully train the model with the new objects?

[glenn-jocher]

Hi @BhavyaDedhia,

Thank you for your detailed feedback and for following the steps provided! It's great to hear that you've made progress with fine-tuning your YOLOv8 model. Let's work on improving the accuracy of your detections.

Here are a few additional suggestions to help enhance the model's performance:

1. Hyperparameter Tuning:

   • Experiment with different learning rates, batch sizes, and other hyperparameters. Sometimes, the default settings may not be optimal for your specific dataset.
   • Example:

     results = model.train(data='path/to/your/data.yaml', epochs=200, imgsz=640, lr0=0.001, batch=16)

2. Data Augmentation:

   • Ensure that your dataset is diverse and includes various augmentations. This can help the model generalize better.
   • You can use built-in augmentation techniques provided by Ultralytics YOLO.

3. Validation and Debugging:

   • Validate your model frequently during training to monitor its performance and adjust accordingly.
   • Use the val mode to evaluate the model on a validation set and check the metrics.

     yolo val model=path/to/your/model.pt data=path/to/your/data.yaml

4. Class Imbalance:

   • If your new classes are significantly fewer or more frequent than the original classes, consider balancing the dataset to avoid bias.

5. Check for Overfitting:

   • Monitor the training and validation loss. If the training loss decreases while the validation loss increases, it might indicate overfitting. In such cases, consider using techniques like dropout or early stopping.

6. Latest Version:

   • Ensure you are using the latest version of the Ultralytics package. Updates often include performance improvements and bug fixes.

     pip install --upgrade ultralytics

If the issue persists, providing a minimum reproducible example (MRE) can be very helpful for us to diagnose the problem effectively. You can find more details on creating an MRE here.

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

[BhavyaDedhia]

results = model.train(data='path/to/your/data.yaml', epochs=200, imgsz=640, lr0=0.001, batch=16)

Can you please explain what is lr0?
and why to keep it 0.001?

[glenn-jocher]

Hi @BhavyaDedhia,

Thank you for your question! The lr0 parameter in the training command stands for the initial learning rate. The learning rate is a crucial hyperparameter that controls how much to change the model in response to the estimated error each time the model weights are updated. Setting it to 0.001 is a common starting point that often works well, but it can be adjusted based on your specific dataset and training behavior.

Here's a brief explanation:

• lr0=0.001: This sets the initial learning rate to 0.001. It's a balance between making significant updates to the model weights and ensuring that the updates are not too large, which could destabilize the training process.

You can experiment with different learning rates to see what works best for your dataset. Sometimes, a lower learning rate might be necessary if the model is not converging well, or a higher learning rate might be beneficial if the training is too slow.

For more detailed guidance on hyperparameter tuning, you might find our training guide helpful.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics package. You can update it using:

pip install --upgrade ultralytics

Additionally, if you run into any specific problems, providing a minimum reproducible example (MRE) can greatly help us diagnose and resolve the issue more effectively. You can find more details on creating an MRE here.

Happy coding! 😊

[BhavyaDedhia]

I tried the above code you have given but still its not working properly there is same issue of accuracy it is detecting wrong

[glenn-jocher]

Hi @BhavyaDedhia,

Thank you for your patience and for providing feedback on your experience. I understand that the accuracy issues are still persisting despite following the previous suggestions. Let's work together to resolve this.

Next Steps:

1. Minimum Reproducible Example (MRE):
   To better understand and diagnose the issue, could you please provide a minimum reproducible example (MRE)? This will help us replicate the problem on our end and offer a more precise solution. You can find guidance on creating an MRE here.

2. Verify Latest Versions:
   Ensure that you are using the latest versions of the Ultralytics package and dependencies. Sometimes, updates include important bug fixes and performance improvements.

   pip install --upgrade ultralytics

3. Hyperparameter Tuning:
   If you haven't already, consider experimenting with different hyperparameters. Sometimes, adjusting the learning rate, batch size, or other parameters can significantly impact model performance.

   results = model.train(data='path/to/your/data.yaml', epochs=200, imgsz=640, lr0=0.0005, batch=32)

4. Data Augmentation:
   Enhance your dataset with various augmentation techniques to improve the model's generalization capabilities. This can help the model perform better on both the original and new classes.

5. Class Balance:
   Ensure that your dataset is balanced. If the new classes are significantly more or less frequent than the original classes, it might lead to biased training. Consider balancing the dataset to avoid this issue.

6. Validation and Debugging:
   Regularly validate your model during training to monitor its performance. Use the val mode to evaluate the model on a validation set and check the metrics.

   yolo val model=path/to/your/model.pt data=path/to/your/data.yaml

If you continue to face issues, please share more details about your dataset and training configuration. This will help us provide more targeted advice.

Thank you for your cooperation, and we look forward to helping you resolve this issue. Happy coding! 😊

[YaoEndless]

Hi Ultralytics team,

I have been trying to use YOLOv10 on the Windows platform these days, but unfortunately it has not been realized, because of a small problem I once encountered. I have searched for all similar problems, but their solution cannot solve my problem, I hope you can help me, thank you very much!
I wrote a piece of Python code to use YOLOv10 for training, here is the code content, I am using the coco dataset

from ultralytics import YOLOv10
import supervision as sv
import cv2
import os

classes = {
0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane', 5: 'bus',
6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light', 10: 'fire hydrant',
11: 'stop sign', 12: 'parking meter', 13: 'bench', 14: 'bird', 15: 'cat',
16: 'dog', 17: 'horse', 18: 'sheep', 19: 'cow', 20: 'elephant', 21: 'bear',
22: 'zebra', 23: 'giraffe', 24: 'backpack', 25: 'umbrella', 26: 'handbag',
27: 'tie', 28: 'suitcase', 29: 'frisbee', 30: 'skis', 31: 'snowboard',
32: 'sports ball', 33: 'kite', 34: 'baseball bat', 35: 'baseball glove',
36: 'skateboard', 37: 'surfboard', 38: 'tennis racket', 39: 'bottle',
40: 'wine glass', 41: 'cup', 42: 'fork', 43: 'knife', 44: 'spoon', 45: 'bowl',
46: 'banana', 47: 'apple', 48: 'sandwich', 49: 'orange', 50: 'broccoli',
51: 'carrot', 52: 'hot dog', 53: 'pizza', 54: 'donut', 55: 'cake',
56: 'chair', 57: 'couch', 58: 'potted plant', 59: 'bed', 60: 'dining table',
61: 'toilet', 62: 'tv', 63: 'laptop', 64: 'mouse', 65: 'remote', 66: 'keyboard',
67: 'cell phone', 68: 'microwave', 69: 'oven', 70: 'toaster', 71: 'sink',
72: 'refrigerator', 73: 'book', 74: 'clock', 75: 'vase', 76: 'scissors',
77: 'teddy bear', 78: 'hair drier', 79: 'toothbrush'
}

model = YOLOv10(r'D:\python3_12\yolov10-main\weights\yolov10b.pt')

image = cv2.imread("E:\coco_test_renamed")

results = model(source=image, conf=0.25, verbose=False)[0]
detections = sv.Detections.from_ultralytics(results)
box_annotator = sv.BoxAnnotator()

labels = [
f"{classes[class_id]} {confidence:.2f}"
for class_id, confidence in zip(detections.class_id, detections.confidence)
]
annotated_image = box_annotator.annotate(
image.copy(), detections=detections, labels=labels
)

cv2.imshow('result', annotated_image)
cv2.waitKey()
cv2.destroyAllWindows()
cv2.imwrite('annotated_dog.jpeg', annotated_image)

After I run the code, the program will report an ERROR, thus terminating the run

D:\python3_12\Anaconda\anaconda3\envs\yolov10_torch\python.exe D:\python3_12\yolov10-main\test.py
Traceback (most recent call last):
File "D:\python3_12\yolov10-main\test.py", line 28, in
image = cv2.imread("E:\coco_test_renamed")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "D:\python3_12\yolov10-main\ultralytics\utils\patches.py", line 26, in imread
return cv2.imdecode(np.fromfile(filename, np.uint8), flags)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
PermissionError: [Errno 13] Permission denied: 'E:\coco_test_renamed'

Process finished with exit code 1

I have tried all methods to solve this problem without success, including changing file permissions on windows and using python to change file permissions and running pycharm with administrator permissions, but all have failed, especially since this problem only occurs when running YOLO.

If you can help me, I will appreciate it very much. Thank you very much.

[glenn-jocher]

Hi there,

Thank you for reaching out and providing detailed information about your issue. It looks like you're encountering a PermissionError when trying to read the image file with OpenCV on your Windows platform.

To help resolve this, please consider the following steps:

1. Verify File Path and Permissions: Ensure that the file path "E:\\coco_test_renamed" is correct and that the file exists. Also, check the file permissions to make sure your script has read access to this file.

2. Check File Path Format: Windows paths can sometimes be tricky. Try using raw strings or double backslashes to avoid escape character issues:

   image = cv2.imread(r"E:\coco_test_renamed")

3. Update Packages: Make sure you are using the latest versions of all relevant packages, including ultralytics, supervision, and opencv-python. You can update them using pip:

   pip install --upgrade ultralytics supervision opencv-python

4. Minimum Reproducible Example: If the issue persists, providing a minimum reproducible example can greatly help in diagnosing the problem. You can find guidance on creating one here: Minimum Reproducible Example Guide.

Here is a simplified version of your code to help isolate the issue:

import cv2

# Ensure the file path is correct and accessible
image_path = r"E:\coco_test_renamed"
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print("Image loaded successfully")

Run this snippet to check if the image loads correctly. If it doesn't, the issue is likely with the file path or permissions.

Please try these steps and let us know if the problem persists. We're here to help!

[YaoEndless]

Hi Thank you very much for your help.

After testing and adjusting the source code, I found that the real problem is not file permissions, but
def imread(filename: str, flags: int = cv2.IMREAD_COLOR)
This function can only accept a single image as the input parameter, and I wrote the file path as the folder path instead of the image path when I entered the parameter, so I caused a Permissionerror: [errno 13] permission denied ERROR.
It is true that we should not only see the surface of ERROR but also understand the underlying causes of ERROR.

Thanks again for your help!

[glenn-jocher]

@YaoEndless hi there,

Thank you for the update and for identifying the root cause of the issue! It's great to hear that you were able to pinpoint the problem with the file path.

Indeed, the cv2.imread function expects a path to a single image file, not a directory. It's a common mistake, and your experience will certainly help others who might encounter a similar issue.

If you have any further questions or run into other issues, feel free to reach out. We're here to help! For more detailed guidance on various topics, you can always refer to our Ultralytics Help page.

Happy coding! 😊

[vamshigaddi]

How to perform inference on video, using the model
This is sample code , I am getting errors, how we can do,classifcation on video, like object detection.
import cv2
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator

Load the YOLO model

model = YOLO('/content/best.pt') # Adjust the model path as necessary
names = model.names

def process_video(input_video_path, output_video_path):

# Open input video
cap = cv2.VideoCapture(input_video_path)
if not cap.isOpened():
    print(f"Error: Could not open video {input_video_path}")
    return

# Get video properties
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter(output_video_path + '.mp4', fourcc, fps, (width, height))

while True:
    ret, im0 = cap.read()
    if not ret:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    annotator = Annotator(im0)

    # Perform object detection and get results
    results = model.predict(im0)
    for result in results:
      probs = result.probs
      labels=model.names[probs.top1]
      for label in zip(labels):
        annotator.text_label(im0,label=label)

    # Write the annotated frame to the output video
    out.write(im0)

# Release resources
out.release()
cap.release()
cv2.destroyAllWindows()

Example usage

input_video_path = '/content/855262-hd_1280_720_25fps.mp4'
output_video_path = 'classification_output_1'
process_video(input_video_path, output_video_path)

[vamshigaddi]

it is video classifcation model and iam not able to inference on video

[glenn-jocher]

@vamshigaddi hello,

Thank you for reaching out! It looks like you're trying to perform video classification using a YOLO model. The code you provided is primarily set up for object detection, but we can adjust it for classification tasks.

Here’s a revised version of your script to handle video classification:

import cv2
from ultralytics import YOLO

# Load the YOLO model
model = YOLO('/content/best.pt')  # Adjust the model path as necessary

def process_video(input_video_path, output_video_path):
    # Open input video
    cap = cv2.VideoCapture(input_video_path)
    if not cap.isOpened():
        print(f"Error: Could not open video {input_video_path}")
        return

    # Get video properties
    fps = cap.get(cv2.CAP_PROP_FPS)
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # Define the codec and create VideoWriter object
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_video_path + '.mp4', fourcc, fps, (width, height))

    while True:
        ret, frame = cap.read()
        if not ret:
            print("Video frame is empty or video processing has been successfully completed.")
            break

        # Perform classification and get results
        results = model.predict(frame)
        for result in results:
            probs = result.probs
            top1_label = model.names[probs.top1]
            confidence = probs.top1conf

            # Annotate the frame with the classification result
            cv2.putText(frame, f"{top1_label}: {confidence:.2f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

        # Write the annotated frame to the output video
        out.write(frame)

    # Release resources
    out.release()
    cap.release()
    cv2.destroyAllWindows()

# Example usage
input_video_path = '/content/855262-hd_1280_720_25fps.mp4'
output_video_path = 'classification_output_1'
process_video(input_video_path, output_video_path)

Key Changes:

1. Model Prediction: Adjusted the prediction loop to handle classification results.
2. Annotation: Added text annotation to display the top-1 classification label and confidence score on each frame.

Additional Tips:

• Ensure you have the latest version of the Ultralytics package installed:

  pip install --upgrade ultralytics

• If you encounter any issues, please provide a minimum reproducible example to help us diagnose the problem more effectively. You can find more details on creating an MRE here.

Feel free to reach out if you have any further questions or run into any issues. Happy coding! 😊

[menibl]

Hello,
I have this code where I'm trying to change the codec type in Linux, but it's not saving the file.
In Windows, it works well.
I want to change the codec to be able to run the MP4 file on an Nginx server because mp4v is not supported by Nginx.
In Windows, using H.264 works fine.You can see that I tried several codecs, but only mp4v is saving the file, yet it cannot be played via Nginx.
Here's a part of my code:

cap = cv2.VideoCapture(video_path)
cap.set(cv2.CAP_PROP_OPEN_TIMEOUT_MSEC, 60000) # 60 seconds
# Check if the video capture is successfully opened
track_history = defaultdict(lambda: [])
track_history_alert = defaultdict(lambda: [])
# track_history_occurences = defaultdict(lambda: [])
# Loop through the video frames
frame_count = 0

codec = cv2.VideoWriter_fourcc(*"mp4v")

#codec = cv2.VideoWriter_fourcc(*"H264")
#codec = cv2.VideoWriter_fourcc(*"AVC1")
codec = cv2.VideoWriter_fourcc(*"h264")
timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
save_path = str(Path("{}/process_{}_{}".format(base_path,camera_index,timestamp)).w

ith_suffix('.mp4'))
print (f"Save Path={save_path}")
file = open('/var/maifocus/maifocus.log', 'a')
fps = 10
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(save_path, codec, fps, (w, h))
object_identifiers = {}
object_not_identifiers = {}
now = 0

[glenn-jocher]

@menibl hello,

Thank you for sharing your issue. It looks like you're encountering problems with saving video files using different codecs on Linux. Here are a few suggestions to help resolve this:

1. Verify Codec Support: Ensure that the codecs you are trying to use (e.g., H.264) are supported and properly installed on your Linux system. You can check this by running:

   ffmpeg -codecs | grep h264

   If H.264 is not listed, you may need to install the necessary codec libraries.

2. Use FFmpeg: Sometimes, OpenCV's built-in codecs may not work as expected on all platforms. You can use FFmpeg to handle the video encoding. Here's an example of how to use FFmpeg with OpenCV:

   import cv2
   import subprocess
   
   video_path = 'input.mp4'
   output_path = 'output.mp4'
   codec = 'libx264'
   fps = 10
   
   cap = cv2.VideoCapture(video_path)
   w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
   h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
   
   ffmpeg_cmd = [
       'ffmpeg',
       '-y',  # Overwrite output file if it exists
       '-f', 'rawvideo',
       '-vcodec', 'rawvideo',
       '-s', f'{w}x{h}',  # Size of one frame
       '-pix_fmt', 'bgr24',
       '-r', str(fps),  # Frames per second
       '-i', '-',  # The input comes from a pipe
       '-an',  # Tells FFMPEG not to expect any audio
       '-vcodec', codec,
       output_path
   ]
   
   process = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE)
   
   while cap.isOpened():
       ret, frame = cap.read()
       if not ret:
           break
       process.stdin.write(frame.tobytes())
   
   cap.release()
   process.stdin.close()
   process.wait()

3. Check File Permissions: Ensure that the directory where you are trying to save the file has the appropriate write permissions.

4. Reproducible Example: If the issue persists, please provide a minimum reproducible example. This will help us diagnose the problem more effectively. You can find guidelines for creating a reproducible example here: Minimum Reproducible Example.

5. Update Packages: Make sure you are using the latest versions of OpenCV and other relevant packages. Sometimes, issues are resolved in newer releases.

If you continue to experience issues, please let us know with additional details, and we'll be happy to assist further. 😊

[Wei1005-design]

I have followed the video but when executing Visual Studio Code it shows this error cannot import name 'YOLO' from 'ultralytics' How can I solve it?

[pderrenger]

@Wei1005-design hi there!

It sounds like you're encountering an import error with the YOLO class from the ultralytics package in Visual Studio Code. Here are a few steps you can take to resolve this issue:

1. Verify Installation: Ensure that the ultralytics package is correctly installed. You can do this by running:

   pip install ultralytics

2. Check Import Statement: Make sure your import statement is correct. It should look like this:

   from ultralytics import YOLO

3. Update Packages: Sometimes, issues arise from outdated packages. Ensure you have the latest version of the ultralytics package:

   pip install --upgrade ultralytics

4. Environment Issues: Ensure that your Python environment in Visual Studio Code is the same one where ultralytics is installed. You can check and select the correct interpreter in Visual Studio Code by clicking on the Python version in the bottom-left corner of the window.

If the issue persists, it would be helpful to have a minimum reproducible example to diagnose the problem more effectively. You can refer to our Minimum Reproducible Example (MRE) Guide for more details on how to create one.

Please let me know if these steps help or if you need further assistance! 😊

[Singh0007]

i update my package so many times but every time i got this errror , i tried on linux and window as well
my point is to convert the yolov models into ncnn format i give u the error

----> 7 model.export(format="ncnn") # creates '/yolov8n_ncnn_model'

File ~/Desktop/venv/lib/python3.10/site-packages/ultralytics/yolo/engine/model.py:342, in YOLO.export(self, **kwargs)
340 args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
341 args.task = self.task
--> 342 return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model)

File ~/Desktop/venv/lib/python3.10/site-packages/torch/utils/_contextlib.py:115, in context_decorator..decorate_context(*args, **kwargs)
112 @functools.wraps(func)
113 def decorate_context(*args, **kwargs):
114 with ctx_factory():
--> 115 return func(*args, **kwargs)

File ~/Desktop/venv/lib/python3.10/site-packages/ultralytics/yolo/engine/exporter.py:155, in Exporter.call(self, model)
153 flags = [x == format for x in fmts]
154 if sum(flags) != 1:
--> 155 raise ValueError(f"Invalid export format='{format}'. Valid formats are {fmts}")
156 jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle = flags # export booleans
158 # Load PyTorch model

Invalid export format='ncnn'. Valid formats are ('torchscript', 'onnx', 'openvino', 'engine', 'coreml', 'saved_model', 'pb', 'tflite', 'edgetpu', 'tfjs', 'paddle')

[Singh0007]

ayone can give scrren shot of camparing the noraml person detection benchmarking with cpu and gpu utilization of yollov8 with python and c++

[pderrenger]

@Singh0007 hello!

Thank you for your interest in comparing the CPU and GPU utilization of YOLOv8 for person detection using Python and C++. While we don't have specific screenshots available, I can guide you on how to perform these benchmarks yourself.

Python Benchmarking

You can use the benchmark mode in YOLOv8 to profile the speed and accuracy of the model. Here's an example of how to do this:

from ultralytics import YOLO

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

# Benchmark the model
results = model.benchmark(data='coco128.yaml', device='cpu')  # for CPU
results = model.benchmark(data='coco128.yaml', device='cuda:0')  # for GPU

C++ Benchmarking

For C++ benchmarking, you can use the exported ONNX model with an inference engine like OpenCV's DNN module or TensorRT. Here’s a basic example using OpenCV:

#include <opencv2/dnn.hpp>
#include <opencv2/opencv.hpp>

int main() {
    cv::dnn::Net net = cv::dnn::readNetFromONNX("yolov8n.onnx");

    // Set backend and target
    net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);  // for CPU
    // net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);  // for GPU

    cv::Mat img = cv::imread("image.jpg");
    cv::Mat blob = cv::dnn::blobFromImage(img, 1.0, cv::Size(640, 640), cv::Scalar(), true, false);

    net.setInput(blob);
    cv::Mat output = net.forward();

    // Process output...
    return 0;
}

Additional Resources

For more detailed instructions and examples, please refer to our documentation:

• YOLOv8 Benchmarking
• YOLOv8 Export

If you encounter any issues or have further questions, please ensure you are using the latest versions of the packages and provide a minimum reproducible example as described here.

Happy coding! 😊

[Singh0007]

i dont know c++ thats why i am asking if there is huge gap between the hardware utilization like CPU and GPU so i switch from python to c++ this is the only reason i am asking if u don't have screen shot then please write the same cpu GPU corresponding with python and c++ i can see here on person detection or any other object please review it an request .

[pderrenger]

Hello @Singh0007,

Thank you for your question! Comparing CPU and GPU utilization between Python and C++ implementations of YOLOv8 can indeed provide valuable insights for optimizing your application.

Python Benchmarking

You can benchmark YOLOv8 in Python using the following code:

from ultralytics import YOLO

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

# Benchmark on CPU
results_cpu = model.benchmark(data='coco128.yaml', device='cpu')

# Benchmark on GPU
results_gpu = model.benchmark(data='coco128.yaml', device='cuda:0')

C++ Benchmarking

For C++, you can use OpenCV's DNN module with an exported ONNX model. Here’s a basic example:

#include <opencv2/dnn.hpp>
#include <opencv2/opencv.hpp>

int main() {
    cv::dnn::Net net = cv::dnn::readNetFromONNX("yolov8n.onnx");

    // Set backend and target
    net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);  // for CPU
    // net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);  // for GPU

    cv::Mat img = cv::imread("image.jpg");
    cv::Mat blob = cv::dnn::blobFromImage(img, 1.0, cv::Size(640, 640), cv::Scalar(), true, false);

    net.setInput(blob);
    cv::Mat output = net.forward();

    // Process output...
    return 0;
}

Key Points

• Python: Easier to set up and use, especially for rapid prototyping and development.
• C++: Potentially offers better performance and lower latency, especially when using optimized libraries like TensorRT.

Next Steps

1. Run the benchmarks: Use the provided code snippets to benchmark both Python and C++ implementations.
2. Compare results: Analyze the CPU and GPU utilization and inference times to decide which implementation suits your needs best.

For more detailed guidance, please refer to our Benchmarking Documentation and Exporting Models.

If you encounter any issues, please ensure you are using the latest versions of the packages and provide a minimum reproducible example as described here.

Happy coding! 😊

[ChrisLearningIT]

Hi Yolo support,

For a project I am trying to use my own configuration model with pre trained weights from yolov8.

from ultralytics import YOLO

# Load a pretrained YOLOv8 model

model = YOLO("/var/scratch/cmr209/ThesisSOD/ultralytics/cfg/models/v8/Yolov8mSpinningConv.yaml").load("yolov8n.pt")

# Validate the model's performance on the COCO dataset
results = model.val(data="/var/scratch/cmr209/ThesisSOD/ultralytics/RealdataCOCO/Coco.yaml", imgsz=640, batch=1)

# Print the validation results
print(results)

I simply replace the Conv layer with my SpinningConv layer. See my Yaml file:

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, SpinningConv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, SpinningConv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, SpinningConv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, SpinningConv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, SpinningConv, [1024, 3,2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f, [256]]  # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 21 (P5/32-large)

  - [[15, 18, 21], 1, Detect, [nc]]  # Detect(P3, P4, P5)

This is my SpinningConv class:

class SpinningConv(nn.Module):
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        super().__init__()
        self.conv = Conv(c1, c2, k, s, p, g, d, act)

    def forward(self, x):
        angles = np.linspace(0, 360, 9)  # This will give you 8 angles from 0 to 315
        outputs = []
        for angle in angles:
            rotated_x = rotate(x, angle, interpolation=Image.BILINEAR)
            print(f"Rotated Input Shape: {rotated_x.shape}")  # Debug print
            convolved_feature_map = self.conv(rotated_x)
            # Resize dynamically to match input size
            resized_feature_map = nn.functional.interpolate(convolved_feature_map, size=x.shape[2:], mode='bilinear', align_corners=False)
            print(f"Resized Feature Map Shape: {resized_feature_map.shape}")  # Debug print
            outputs.append(resized_feature_map)
        
        output = torch.stack(outputs, dim=0).mean(dim=0)
        return output

however dont get the layers right, because i get the following error:

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/var/scratch/cmr209/miniconda/lib/python3.11/site-packages/torch/nn/modules/conv.py", line 460, in forward
    return self._conv_forward(input, self.weight, self.bias)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/var/scratch/cmr209/miniconda/lib/python3.11/site-packages/torch/nn/modules/conv.py", line 456, in _conv_forward
    return F.conv2d(input, weight, bias, self.stride,
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: Given groups=1, weight of size [3, 64, 2, 2], expected input[1, 3, 256, 256] to have 64 channels, but got 3 channels instead

Im using the Conv class in my SpinningClass so I suspect everything should be the same. Do you see any mistakes?

[pderrenger]

@ChrisLearningIT hello,

Thank you for reaching out and providing detailed information about your project and the issue you're encountering. It looks like you're on the right track with customizing the YOLOv8 model by integrating your SpinningConv layer. However, the error you're seeing indicates a mismatch in the expected input channels for the convolutional layer.

The error message:

RuntimeError: Given groups=1, weight of size [3, 64, 2, 2], expected input[1, 3, 256, 256] to have 64 channels, but got 3 channels instead

suggests that the input to your SpinningConv layer is not matching the expected number of channels. Specifically, it seems like the SpinningConv layer is expecting an input with 64 channels, but it's receiving an input with only 3 channels.

Debugging Steps:

1. Check Input Channels: Ensure that the input to your SpinningConv layer has the correct number of channels. The first layer in your model should match the number of input channels (typically 3 for RGB images).

2. Modify the SpinningConv Layer: Adjust the initialization of your SpinningConv layer to correctly handle the input channels. Here’s an example modification:

   class SpinningConv(nn.Module):
       def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
           super().__init__()
           self.conv = Conv(c1, c2, k, s, p, g, d, act)
   
       def forward(self, x):
           angles = np.linspace(0, 360, 9)  # This will give you 8 angles from 0 to 315
           outputs = []
           for angle in angles:
               rotated_x = rotate(x, angle, interpolation=Image.BILINEAR)
               print(f"Rotated Input Shape: {rotated_x.shape}")  # Debug print
               convolved_feature_map = self.conv(rotated_x)
               # Resize dynamically to match input size
               resized_feature_map = nn.functional.interpolate(convolved_feature_map, size=x.shape[2:], mode='bilinear', align_corners=False)
               print(f"Resized Feature Map Shape: {resized_feature_map.shape}")  # Debug print
               outputs.append(resized_feature_map)
           
           output = torch.stack(outputs, dim=0).mean(dim=0)
           return output

3. Verify Model Configuration: Ensure that your model configuration YAML file correctly specifies the input and output channels for each layer. For example, the first SpinningConv layer should have c1 set to 3 (for RGB images) and c2 set to the desired number of output channels.

Example YAML Adjustment:

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, SpinningConv, [3, 64, 3, 2]]  # 0-P1/2, c1=3 for RGB input
  - [-1, 1, SpinningConv, [64, 128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, SpinningConv, [128, 256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, SpinningConv, [256, 512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, SpinningConv, [512, 1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

Additional Resources:

• Minimum Reproducible Example (MRE): If the issue persists, please provide a minimum reproducible example to help us diagnose the problem more effectively. You can find more information on how to create an MRE here.
• Latest Versions: Ensure you are using the latest versions of the Ultralytics YOLO package and dependencies to avoid any issues that might have been resolved in recent updates.

Feel free to reach out if you have any further questions or need additional assistance. Happy coding! 😊