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

[swarnalathayv]

That's very kind of you. I have started the training. My training set consists of 60 images. While in every epoch images it is showing 12 and mAP as zero. Am I wrong anywhere?

…

On Sun, Jun 9, 2024 at 1:27 AM Glenn Jocher ***@***.***> wrote: Hello Swarnalatha, Thank you for your kind words! 😊 We're thrilled to hear that the guidance provided has been helpful. Regarding your current progress, it looks like you're on the right track with organizing your dataset and integrating custom modules into your YOLO model. Let's ensure everything is set up correctly: Dataset Organization and YAML Configuration Your directory structure and YAML configuration should look like this: *Directory Structure:* dataset/ ├── images/ │ ├── train/ │ └── val/ └── labels/ ├── train/ └── val/ *YAML File Configuration:* path: ../dataset # path to dataset root directorytrain: images/train # train images (relative to 'path')val: images/val # val images (relative to 'path')test: # test images (optional)nc: 80 # number of classesnames: ['class1', 'class2', ...] # list of class names Ensure that the paths in your YAML file are relative to the path specified at the top. This should resolve the "str object does not support item assignment" error. Adding Ghost Bottleneck and CARAFE Modules To integrate custom modules like Ghost Bottleneck and CARAFE, follow these steps: 1. *Define Custom Modules:* Create a new Python file, e.g., custom_modules.py, and implement your modules: import torchimport torch.nn as nn class GhostBottleneck(nn.Module): # Define your Ghost Bottleneck module here pass class CARAFE(nn.Module): # Define your CARAFE module here pass 2. *Modify the Model Architecture:* Integrate these custom modules into the YOLO model architecture by editing the model's YAML configuration file or directly modifying the model's Python code: # Example of modifying the model.yamlbackbone: # Add GhostBottleneck and CARAFE layers in the backbone - [GhostBottleneck, ...] - [CARAFE, ...] 3. *Update the Model Code:* Ensure the custom modules are imported and used in the model definition: from custom_modules import GhostBottleneck, CARAFE class CustomYOLOModel(nn.Module): def __init__(self): super(CustomYOLOModel, self).__init__() self.layer1 = GhostBottleneck(...) self.layer2 = CARAFE(...) # Add other layers and configurations 4. *Training and Testing:* Train your modified model using the standard training scripts provided by Ultralytics: yolo train data=your_data.yaml model=custom_model.yaml epochs=100 Additional Steps 1. *Minimum Reproducible Example (MRE):* If you encounter further issues, please provide a minimum reproducible example. This helps us investigate and resolve your issue more efficiently. You can find more details on creating an MRE here <https://docs.ultralytics.com/help/minimum_reproducible_example>. 2. *Version Check:* Ensure you are using the latest versions of torch and ultralytics. If not, please upgrade your packages and try again. If you need any more assistance or detailed guidance, feel free to ask. 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/A6BY3KE6R565TXXUWEPBTZ3ZGNO2DAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOMJWGA2DS> . 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]

Hi Swarnalatha,

Thank you for your kind words and for sharing your progress! 😊

Regarding your training issue, it seems like there might be a couple of things to check:

1. Dataset Size and Configuration: With 60 images in your training set, it's expected that each epoch processes a subset of these images based on your batch size. Could you verify your batch size setting? If it's set to 12, this would explain why you see 12 images per epoch.

2. Zero mAP: A zero mAP (mean Average Precision) typically indicates that the model isn't detecting any objects correctly. This could be due to several reasons:

   • Annotations: Ensure that your annotations are correctly formatted and match the images.
   • Classes: Verify that the number of classes in your dataset configuration file (.yaml) matches the actual classes in your dataset.
   • Training Duration: With only 60 images, the model might need more epochs to start learning effectively. Consider increasing the number of epochs.

To help us investigate further, could you please provide a minimum reproducible example (MRE) of your code? This will allow us to reproduce the issue on our end and provide a more accurate solution. You can find more details on creating an MRE here.

Additionally, please ensure you are using the latest versions of torch and ultralytics. You can update your packages with the following commands:

pip install --upgrade torch ultralytics

Here's a quick example of how you might set up your training script:

from ultralytics import YOLO

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

# Set up training arguments
args = {
    'data': 'path/to/your_data.yaml',
    'epochs': 100,
    'batch': 12,
    'imgsz': 640
}

# Train the model
results = model.train(**args)

If you need further assistance, feel free to ask. We're here to help! 🚀

[swarnalathayv]

Thank you, I will do that. For accelerating the speed I am trying to use GPU. In my system NVidia GeForce GT730 version GPU. And I installed CuDA toolkit and Cudnn. But my jupyter note book is not using the GPU. I checked the kernel. It is not detecting.

…

On Mon, 10 Jun, 2024, 5:15 pm Paula Derrenger, ***@***.***> wrote: Hi Swarnalatha, Thank you for your kind words and for sharing your progress! 😊 Regarding your training issue, it seems like there might be a couple of things to check: 1. *Dataset Size and Configuration*: With 60 images in your training set, it's expected that each epoch processes a subset of these images based on your batch size. Could you verify your batch size setting? If it's set to 12, this would explain why you see 12 images per epoch. 2. *Zero mAP*: A zero mAP (mean Average Precision) typically indicates that the model isn't detecting any objects correctly. This could be due to several reasons: - *Annotations*: Ensure that your annotations are correctly formatted and match the images. - *Classes*: Verify that the number of classes in your dataset configuration file (.yaml) matches the actual classes in your dataset. - *Training Duration*: With only 60 images, the model might need more epochs to start learning effectively. Consider increasing the number of epochs. To help us investigate further, could you please provide a minimum reproducible example (MRE) of your code? This will allow us to reproduce the issue on our end and provide a more accurate solution. You can find more details on creating an MRE here <https://docs.ultralytics.com/help/minimum_reproducible_example>. Additionally, please ensure you are using the latest versions of torch and ultralytics. You can update your packages with the following commands: pip install --upgrade torch ultralytics Here's a quick example of how you might set up your training script: 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 } # Train the modelresults = model.train(**args) If you need further assistance, feel free to ask. 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/A6BY3KCYVQW4U32WDY673IDZGWGVRAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOMRWGQ2DA> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

Hi Swarnalatha,

Thank you for providing more details about your setup! 😊 Let's see if we can get your GPU up and running for your Jupyter notebook.

First, let's verify that your system is correctly set up to use the GPU. Here are a few steps to troubleshoot and ensure everything is configured properly:

1. Check CUDA and cuDNN Installation:
   Ensure that CUDA and cuDNN are correctly installed and compatible with your GPU. You can verify the CUDA installation by running:

   nvcc --version

   This should display the CUDA version installed on your system.

2. Verify GPU Availability in PyTorch:
   Make sure PyTorch can detect your GPU. You can run the following code in a Python environment:

   import torch
   print(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 PyTorch and Ultralytics:
   Ensure you are using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

4. 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 model
   model = YOLO('yolov8n.pt')
   
   # Set up training arguments
   args = {
       'data': 'path/to/your_data.yaml',
       'epochs': 100,
       'batch': 12,
       'imgsz': 640,
       'device': 'cuda'  # Ensure the model uses the GPU
   }
   
   # Train the model
   results = model.train(**args)

If your Jupyter notebook still does not detect the GPU, please ensure that the notebook kernel is running in the same environment where CUDA and PyTorch are installed. You can check the kernel environment by running:

!which python

This should point to the Python executable in your environment with CUDA and PyTorch.

If you continue to face issues, 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.

Feel free to reach out if you need further assistance. We're here to help! 🚀

[swarnalathayv]

Thanks for the reply. The installed GPU driver in my system is in an older version. Torch is not supporting that version. I will upgrade my GPU and come back if any clarifications are required.

…

On Tue, Jun 11, 2024 at 1:02 AM Paula Derrenger ***@***.***> wrote: Hi Swarnalatha, Thank you for providing more details about your setup! 😊 Let's see if we can get your GPU up and running for your Jupyter notebook. First, let's verify that your system is correctly set up to use the GPU. Here are a few steps to troubleshoot and ensure everything is configured properly: 1. *Check CUDA and cuDNN Installation*: Ensure that CUDA and cuDNN are correctly installed and compatible with your GPU. You can verify the CUDA installation by running: nvcc --version This should display the CUDA version installed on your system. 2. *Verify GPU Availability in PyTorch*: Make sure PyTorch can detect your GPU. You can run the following code in a Python environment: 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 PyTorch and Ultralytics*: Ensure you are using the latest versions of torch and ultralytics. You can update them using: pip install --upgrade torch ultralytics 4. *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 your Jupyter notebook still does not detect the GPU, please ensure that the notebook kernel is running in the same environment where CUDA and PyTorch are installed. You can check the kernel environment by running: !which python This should point to the Python executable in your environment with CUDA and PyTorch. If you continue to face issues, 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/A6BY3KFRB4PIOKRKMVZOBJTZGX5LPAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOMZRGA4DK> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

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

[glenn-jocher]

@swarnalathayv hi Swarnalatha,

Thank you for the update! 😊 It's great to hear that you're planning to upgrade your GPU driver. Ensuring compatibility between your GPU driver and PyTorch is crucial for leveraging the full power of your hardware.

Once you've upgraded your GPU driver, please follow these steps to verify everything is set up correctly:

1. Check CUDA and cuDNN Installation:
   Ensure that CUDA and cuDNN are correctly installed and compatible with your GPU. You can verify the CUDA installation by running:

   nvcc --version

   This should display the CUDA version installed on your system.

2. Verify GPU Availability in PyTorch:
   Make sure PyTorch can detect your GPU. You can run the following code in a Python environment:

   import torch
   print(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 PyTorch and Ultralytics:
   Ensure you are using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

4. 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 model
   model = YOLO('yolov8n.pt')
   
   # Set up training arguments
   args = {
       'data': 'path/to/your_data.yaml',
       'epochs': 100,
       'batch': 12,
       'imgsz': 640,
       'device': 'cuda'  # Ensure the model uses the GPU
   }
   
   # Train the model
   results = model.train(**args)

If your Jupyter notebook still does not detect the GPU, please ensure that the notebook kernel is running in the same environment where CUDA and PyTorch are installed. You can check the kernel environment by running:

!which python

This should point to the Python executable in your environment with CUDA and PyTorch.

If you continue to face issues, 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.

Feel free to reach out if you need further assistance. We're here to help! 🚀

[swarnalathayv]

Hello, In the model YAML file also should we change the number of classes? Is that the reason for showing mAP as zero?

…

On Mon, Jun 10, 2024 at 12:04 PM Swarna Y.V ***@***.***> wrote: That's very kind of you. I have started the training. My training set consists of 60 images. While in every epoch images it is showing 12 and mAP as zero. Am I wrong anywhere? On Sun, Jun 9, 2024 at 1:27 AM Glenn Jocher ***@***.***> wrote: > Hello Swarnalatha, > > Thank you for your kind words! 😊 We're thrilled to hear that the > guidance provided has been helpful. > > Regarding your current progress, it looks like you're on the right track > with organizing your dataset and integrating custom modules into your YOLO > model. Let's ensure everything is set up correctly: > Dataset Organization and YAML Configuration > > Your directory structure and YAML configuration should look like this: > > *Directory Structure:* > > dataset/ > ├── images/ > │ ├── train/ > │ └── val/ > └── labels/ > ├── train/ > └── val/ > > *YAML File Configuration:* > > path: ../dataset # path to dataset root directorytrain: images/train # train images (relative to 'path')val: images/val # val images (relative to 'path')test: # test images (optional)nc: 80 # number of classesnames: ['class1', 'class2', ...] # list of class names > > Ensure that the paths in your YAML file are relative to the path > specified at the top. This should resolve the "str object does not support > item assignment" error. > Adding Ghost Bottleneck and CARAFE Modules > > To integrate custom modules like Ghost Bottleneck and CARAFE, follow > these steps: > > 1. > > *Define Custom Modules:* > Create a new Python file, e.g., custom_modules.py, and implement your > modules: > > import torchimport torch.nn as nn > class GhostBottleneck(nn.Module): > # Define your Ghost Bottleneck module here > pass > class CARAFE(nn.Module): > # Define your CARAFE module here > pass > > 2. > > *Modify the Model Architecture:* > Integrate these custom modules into the YOLO model architecture by > editing the model's YAML configuration file or directly modifying the > model's Python code: > > # Example of modifying the model.yamlbackbone: > # Add GhostBottleneck and CARAFE layers in the backbone > - [GhostBottleneck, ...] > - [CARAFE, ...] > > 3. > > *Update the Model Code:* > Ensure the custom modules are imported and used in the model > definition: > > from custom_modules import GhostBottleneck, CARAFE > class CustomYOLOModel(nn.Module): > def __init__(self): > super(CustomYOLOModel, self).__init__() > self.layer1 = GhostBottleneck(...) > self.layer2 = CARAFE(...) > # Add other layers and configurations > > 4. > > *Training and Testing:* > Train your modified model using the standard training scripts > provided by Ultralytics: > > yolo train data=your_data.yaml model=custom_model.yaml epochs=100 > > > Additional Steps > > 1. > > *Minimum Reproducible Example (MRE):* > If you encounter further issues, please provide a minimum > reproducible example. This helps us investigate and resolve your issue more > efficiently. You can find more details on creating an MRE here > <https://docs.ultralytics.com/help/minimum_reproducible_example>. > 2. > > *Version Check:* > Ensure you are using the latest versions of torch and ultralytics. If > not, please upgrade your packages and try again. > > If you need any more assistance or detailed guidance, feel free to ask. > 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/A6BY3KE6R565TXXUWEPBTZ3ZGNO2DAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOMJWGA2DS> > . > You are receiving this because you were mentioned.Message ID: > ***@***.*** > com> > -- Thanks & Regards Swarnalatha YV Sci/ Eng - SC VSSC, Trivandrum. Ph: 0471-256-4375

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

[glenn-jocher]

@swarnalathayv hello Swarnalatha,

Thank you for reaching out! 😊

Yes, you should definitely update the number of classes (nc) in your model YAML file to match the number of classes in your custom dataset. If this is not set correctly, it could indeed result in issues like mAP showing as zero.

Here’s a quick checklist to ensure everything is set up correctly:

1. Update the Model YAML File:
   Ensure that the nc parameter in your model YAML file reflects the number of classes in your dataset. For example, if you have 3 classes, it should look like this:

   nc: 3

2. Verify Dataset YAML File:
   Make sure your dataset YAML file correctly lists the number of classes and their names:

   path: ../dataset  # path to dataset root directory
   train: images/train  # train images (relative to 'path')
   val: images/val  # val images (relative to 'path')
   nc: 3  # number of classes
   names: ['class1', 'class2', 'class3']  # list of class names

3. Check Training Logs:
   Ensure that the training logs are showing the correct number of classes and that the images are being processed correctly. If the mAP is zero, it might indicate an issue with the dataset or the configuration.

4. Minimum Reproducible Example (MRE):
   If the issue persists, please provide a minimum reproducible example (MRE) so we can better understand and investigate the problem. You can find more details on creating an MRE here: Minimum Reproducible Example Guide.

5. Version Check:
   Ensure you are using the latest versions of torch and ultralytics. If not, please upgrade your packages and try again.

Here’s a quick example of how to train your model with the updated configurations:

from ultralytics import YOLO

# Load your custom model
model = YOLO('path/to/custom_model.yaml')

# Train the model
model.train(data='path/to/your_data.yaml', epochs=100)

If you need any more assistance or detailed guidance, feel free to ask. We're here to help! 🚀

[ArfazDS]

Hi, I had earlier trained my custom data with YOLO v8. Now I want to train with YOLOv10, I looked at the official site for the training code & found the following, did exactly the same step:

from ultralytics import YOLO

Load YOLOv10n model from scratch

model = YOLO("yolov10b.yaml")

Train the model

model.train(data="data.yaml", epochs=100, imgsz=640)

But I'm getting the following error:

NotImplementedError: WARNING 'YOLO' model does not support '_new' mode for 'None' task yet.

I have all the mentioned files. Can you help me out?
Thank you

[pderrenger]

@ArfazDS hi there! 👋

Thank you for reaching out. It looks like you're encountering an issue while trying to train a YOLOv10 model. The error message you're seeing, NotImplementedError: WARNING 'YOLO' model does not support '_new' mode for 'None' task yet, suggests that there might be a configuration or compatibility issue.

Here are a few steps to help troubleshoot and resolve this:

1. Verify Versions: Ensure you are using the latest versions of both torch and ultralytics. You can upgrade them using the following commands:

   pip install --upgrade torch ultralytics

2. Minimum Reproducible Example: If the issue persists, please provide a minimum reproducible example. This helps us understand the context and reproduce the issue on our end. You can find more details on creating a minimum reproducible example here: Minimum Reproducible Example Guide.

3. Check Model Configuration: Ensure that the yolov10b.yaml file is correctly configured and exists in the specified path. Sometimes, a typo or misconfiguration in the YAML file can lead to such errors.

4. Training Code: Here’s a quick example to ensure everything is set up correctly:

   from ultralytics import YOLO
   
   # Load YOLOv10n model from scratch
   model = YOLO("yolov10b.yaml")
   
   # Train the model
   model.train(data="data.yaml", epochs=100, imgsz=640)

If you've verified all the above and the issue still persists, please share the exact versions of torch and ultralytics you are using, along with any additional error messages or logs. This will help us diagnose the problem more effectively.

Feel free to check out our FAQ for more common questions and solutions.

Looking forward to your response, and happy coding! 😊

[Me3ue]

I changed the network in source code and have trained successfully. But when I want to convert the model into onnx with yolo export model=yolov8-efficientViT.yaml imgsz=640 format=onnx opset=12, it goes wrong: 'FileNotFoundError: yolov8-efficientViT.yaml' does not exist . I wonder where should I put my .yaml and what should I do to manage to convert my model?

[Me3ue]

Btw, the yolov8-efficientViT.yaml is in \ultralytics\cfg\models\v8\yolov8-efficientViT.yaml now.

[glenn-jocher]

Hi there!

It sounds like you've made some great progress with your custom model! To address the FileNotFoundError you're encountering, you need to ensure that the yolov8-efficientViT.yaml file is correctly placed and referenced.

Here's what you can do:

1. File Placement: Ensure that your yolov8-efficientViT.yaml file is located in the ultralytics/cfg/models/v8/ directory. This is the standard directory for model configuration files.

2. Correct Path Reference: When you run the export command, make sure to provide the correct relative or absolute path to your YAML file. For example:

   yolo export model=ultralytics/cfg/models/v8/yolov8-efficientViT.yaml imgsz=640 format=onnx opset=12

3. Verify Versions: Ensure you are using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

4. Minimum Reproducible Example (MRE): If the issue persists, please provide a minimum reproducible example so we can better understand and replicate the problem. You can find more details on creating an MRE here.

If you follow these steps and still encounter issues, please share more details or any error messages you receive. This will help us assist you more effectively.

Happy coding! 🚀

[vamshigaddi]

Hi,
I want to know is there any action recognition model in Yolo and Person reidentification models. Is it possible to build those model on top of existing Yolo models? I need those models in my project.

[glenn-jocher]

Hi there,

Thank you for your interest in Ultralytics YOLO models! Currently, YOLO models primarily focus on tasks such as object detection, segmentation, classification, and pose/keypoint estimation. Unfortunately, we do not have built-in models specifically for action recognition or person re-identification.

However, you can certainly build these models on top of existing YOLO models. For action recognition, you could use YOLO for detecting objects or persons in each frame and then apply a temporal model (like LSTM or 3D CNN) to analyze the sequence of frames. For person re-identification, you can use YOLO to detect persons and then extract features from the detected regions using a separate re-identification model.

Here's a high-level approach to get you started:

1. Action Recognition:

   • Use YOLO to detect objects/persons in each frame.
   • Extract features from each detected frame.
   • Feed these features into a temporal model (e.g., LSTM, 3D CNN) to recognize actions.

2. Person Re-identification:

   • Use YOLO to detect persons in images or video frames.
   • Extract features from the detected bounding boxes.
   • Use a re-identification model to match these features across different frames or cameras.

For more detailed guidance and examples, you might want to explore additional resources or research papers on these topics. If you have any specific questions or run into issues, feel free to ask!

Happy coding! 😊

[vamshigaddi]

Thank you, Glenn, for your information.

[glenn-jocher]

Hi there,

Thank you for reaching out and for your interest in Ultralytics YOLO models! 😊

To better assist you, could you please provide a minimum reproducible example of the issue you're encountering? This will help us understand the problem more clearly and work towards a solution. You can find guidance on creating a minimum reproducible example here. It's crucial for us to be able to reproduce the bug before we can investigate it further.

Additionally, please ensure that you are using the most recent versions of torch and ultralytics. If you haven't already, try upgrading your packages and see if the issue persists:

pip install --upgrade torch ultralytics

Once you have the reproducible example and have confirmed you're on the latest versions, please share the details, and we'll be happy to assist you further.

Thank you for your cooperation and understanding!

[Etty-Cohen]

Hi, I want to save yolo8-s model (without self training) into onnx .
I do it like it explained here https://docs.ultralytics.com/modes/export/#usage-examples
but I get error in infference from onnx yolo model.
my code:
'''
model = YOLO('yolov8s.pt')
model.export(format="onnx", opset=9)
onnx_model = YOLO("yolov8s.onnx")#, task='detect'
image = cv2.imread('/path/to/image.png')
original_image = image.copy() # Keep a copy of the original for drawing
height, width = image.shape[:2]
image = cv2.resize(image, (640, 640))
results = onnx_model(image)
'''
I tried also with default opset. the model saved with onnx extention.
but that line make error: results = onnx_model(image)

the error is:
'''
Loading yolov8s.onnx for ONNX Runtime inference...
/home/etty/.local/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py:53: UserWarning: Specified provider 'CUDAExecutionProvider' is not in available provider names.Available providers: 'CPUExecutionProvider'
warnings.warn("Specified provider '{}' is not in available provider names."
Traceback (most recent call last):
File "convert_pt_model_to_onnx.py", line 15, in
results = onnx_model(image)
File "/home/.local/lib/python3.8/site-packages/ultralytics/engine/model.py", line 177, in call
return self.predict(source, stream, **kwargs)
File "/home/.local/lib/python3.8/site-packages/ultralytics/engine/model.py", line 446, in predict
self.predictor.setup_model(model=self.model, verbose=is_cli)
File "/home/.local/lib/python3.8/site-packages/ultralytics/engine/predictor.py", line 303, in setup_model
self.model = AutoBackend(
File "/usr/local/lib/python3.8/dist-packages/torch/utils/_contextlib.py", line 115, in decorate_context
return func(*args, *kwargs)
File "/home/.local/lib/python3.8/site-packages/ultralytics/nn/autobackend.py", line 192, in init
session = onnxruntime.InferenceSession(w, providers=providers)
File "/home/.local/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py", line 283, in init
self._create_inference_session(providers, provider_options, disabled_optimizers)
File "/home/.local/lib/python3.8/site-packages/onnxruntime/capi/onnxruntime_inference_collection.py", line 310, in _create_inference_session
sess = C.InferenceSession(session_options, self._model_path, True, self._read_config_from_model)
onnxruntime.capi.onnxruntime_pybind11_state.Fail: [ONNXRuntimeError] : 1 : FAIL : Load model from yolov8s.onnx failed:/onnxruntime_src/onnxruntime/core/graph/model.cc:111 onnxruntime::Model::Model(onnx::ModelProto&&, const PathString&, const IOnnxRuntimeOpSchemaRegistryList, const onnxruntime::logging::Logger&) Unknown model file format version.
'''

[pderrenger]

@Etty-Cohen hi there,

Thank you for reaching out and providing detailed information about the issue you're encountering. Let's work through this together.

Firstly, ensure you are using the latest versions of torch, ultralytics, and onnxruntime. You can update them using the following commands:

pip install --upgrade torch ultralytics onnxruntime

Next, let's address the error you're seeing. It appears that the ONNX model is not loading correctly due to a version mismatch or an unsupported provider. Here are a few steps to troubleshoot and resolve this:

1. Check ONNX Model Export:
   Ensure the model is exported correctly. You can try exporting without specifying the opset to use the default:

   from ultralytics import YOLO
   
   # Load the YOLOv8 model
   model = YOLO('yolov8s.pt')
   
   # Export the model to ONNX format
   model.export(format="onnx")

2. Verify ONNX Runtime Installation:
   Make sure onnxruntime is installed and up-to-date:

   pip install --upgrade onnxruntime

3. Load ONNX Model with CPU Provider:
   If CUDA is not available or causing issues, try using the CPU provider explicitly:

   import cv2
   from ultralytics import YOLO
   
   # Load the exported ONNX model with CPU provider
   onnx_model = YOLO("yolov8s.onnx", providers=['CPUExecutionProvider'])
   
   # Read and preprocess the image
   image = cv2.imread('/path/to/image.png')
   image = cv2.resize(image, (640, 640))
   
   # Run inference
   results = onnx_model(image)

If the issue persists, please provide a minimum reproducible example (MRE) that includes the exact steps and code you are using. This will help us investigate further. You can find more details on creating an MRE here: Minimum Reproducible Example Guide.

For additional resources and detailed guides, you can visit our ONNX Export Documentation.

Feel free to reach out if you have any more questions or need further assistance. We're here to help!

[Etty-Cohen]

@pderrenger Thank you very very much
I appreciate it very much!
upgrade torch ultralytics solved the problem

[pderrenger]

@Etty-Cohen You're very welcome! 😊 I'm glad to hear that upgrading torch and ultralytics resolved the issue for you.

If you have any more questions or run into any other issues, feel free to reach out. We're here to help!

Happy coding! 🚀

[Me3ue]

I wonder why it goes wrong: from ultralytics.yolo.data.dataloaders.v5loader import create_dataloader ModuleNotFoundError: No module named 'ultralytics.yolo.data.dataloaders.v5loader'😭

[pderrenger]

Hi there,

Thank you for reaching out! It looks like you're encountering a ModuleNotFoundError for ultralytics.yolo.data.dataloaders.v5loader. This issue might be due to a few reasons, such as using an outdated version of the ultralytics package or a change in the module structure.

To help you better, could you please provide a minimum reproducible example (MRE) of your code? This will allow us to reproduce the issue on our end and investigate it more effectively. You can find guidelines on creating an MRE here: Minimum Reproducible Example Guide.

In the meantime, please ensure you are using the latest versions of torch and ultralytics. You can upgrade them using the following commands:

pip install --upgrade torch ultralytics

If the issue persists after upgrading, please share the MRE, and we'll be happy to assist further.

Thank you for your cooperation! 😊

[Me3ue]

I wonder why it goes wrong: from ultralytics.yolo.data.dataloaders.v5loader import create_dataloader ModuleNotFoundError: No module named 'ultralytics.yolo.data.dataloaders.v5loader'😭

[pderrenger]

@Me3ue hi there! 👋

It looks like you're encountering a ModuleNotFoundError for ultralytics.yolo.data.dataloaders.v5loader. This issue might be due to a few reasons:

1. Module Path Changes: The module path you're using might have changed in recent updates. Please ensure you're using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

2. Correct Import Path: The import path might have been updated or deprecated. Please refer to the latest Ultralytics documentation for the correct module paths and usage.

3. Minimum Reproducible Example: If the issue persists, could you provide a minimum reproducible example? This will help us better understand and diagnose the problem. You can find guidelines on creating an MRE here.

Here's a quick example of how you might structure your code:

from ultralytics import YOLO

# Example code to reproduce the issue
model = YOLO('yolov8n.pt')
results = model.predict('path/to/image.jpg')
print(results)

Please ensure your code is up-to-date with the latest documentation and try again. If the problem continues, sharing your MRE will be very helpful for us to investigate further.

Feel free to check out our Help page for more resources and support.

Best regards and happy coding! 😊

[swarnalathayv]

Hello, I installed CUDA 12.5 which is compatible with torch. When I am trying to import in jupyter notebook., it is showing no module found with the name of torch. But in IDLE it is returning as true when I ask for cuda availability. What might be the problem?

…

On Tue, 11 Jun, 2024, 1:02 am Paula Derrenger, ***@***.***> wrote: Hi Swarnalatha, Thank you for providing more details about your setup! 😊 Let's see if we can get your GPU up and running for your Jupyter notebook. First, let's verify that your system is correctly set up to use the GPU. Here are a few steps to troubleshoot and ensure everything is configured properly: 1. *Check CUDA and cuDNN Installation*: Ensure that CUDA and cuDNN are correctly installed and compatible with your GPU. You can verify the CUDA installation by running: nvcc --version This should display the CUDA version installed on your system. 2. *Verify GPU Availability in PyTorch*: Make sure PyTorch can detect your GPU. You can run the following code in a Python environment: 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 PyTorch and Ultralytics*: Ensure you are using the latest versions of torch and ultralytics. You can update them using: pip install --upgrade torch ultralytics 4. *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 your Jupyter notebook still does not detect the GPU, please ensure that the notebook kernel is running in the same environment where CUDA and PyTorch are installed. You can check the kernel environment by running: !which python This should point to the Python executable in your environment with CUDA and PyTorch. If you continue to face issues, 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/A6BY3KFRB4PIOKRKMVZOBJTZGX5LPAVCNFSM6AAAAABCZTU2BOVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOMZRGA4DK> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

@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 torch
   print(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 model
   model = YOLO('yolov8n.pt')
   
   # Set up training arguments
   args = {
       'data': 'path/to/your_data.yaml',
       'epochs': 100,
       'batch': 12,
       'imgsz': 640,
       'device': 'cuda'  # Ensure the model uses the GPU
   }
   
   # Train the model
   results = 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.

Feel free to reach out if you need further assistance. We're here to help! 🚀

[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! 😊