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.

[glenn-jocher]

@anirudhjbabu1 to save images with detected objects and those without into separate folders, you can modify the output logic in your inference script. After running predictions with YOLOv8, you can check if any objects were detected and then save the image to the appropriate folder based on this condition.

For images with detections, you might save them to a folder named 'detected', and for those without, to a folder named 'not_detected'. This will require you to write a conditional statement that checks the number of detections in each image and then uses a file-saving function to store the image in the correct directory.

Remember to create the directories before running the script if they don't already exist, and ensure you have the necessary permissions to write files to the desired location. 📂🚫📂

[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.

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

[HenanAlbert]

Hi! I have a question, what are the CPU and RAM requirements for using this model to make image predictions? I mean in the processing of predicting rather than training. Thank you so much.

[glenn-jocher]

@HenanAlbert for image predictions, a modern CPU with at least 4 cores and 8GB of RAM should suffice for efficient processing. For more detailed requirements, please refer to the Ultralytics documentation.

[lei-yang-gc]

Hi there, Thank you for your work! I noticed that the results of https://docs.ultralytics.com/models/yolo-world/ is different from https://huggingface.co/spaces/stevengrove/YOLO-World. I am wondering do you evaluate the performance between them. Can we load YOLO-World open source model in ultralytics lib? Thank you!

[glenn-jocher]

@lei-yang-gc thank you for your interest! The YOLO-World model can indeed be loaded using the Ultralytics library. Differences in results may arise from variations in configurations or datasets used. For further details, please refer to the Ultralytics documentation.

[ezcsdeveloper]

YOLOV10n... model.track...: log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " KeyError n

My object detection python (ver 3.10) program running in Windows 11 (23H2) in my miniPC (Intel Alder Lake N200 CPU integrated UHD Graphics, 16GB DDR4 RAM), using a customed YoloV10n trained model, is crashing with the following error:

log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " KeyError 7

It crashes after completely processing around 15 video frames, specifically in this line (when running inference):

inference_imageFrame_results = model.track(imageFrame, imgsz=640, persist=True, conf=Minimum_Acceptable_Score, max_det=10, stream_buffer=True)

My program uses a customed model that was trained with a data.yaml file that had the following content:

train: D:\...\images\train 
val: D:\...\images\val 
test: D:\...\images\test 
is_coco: False 
nc: 7  
names: ['axle', 'minivan','pickup','sedan','suv','truck','tractor']

After training the model, I generated an OpenVINO version of it, by exporting it as follows:

model = YOLO(pt_model) model.export(format="openvino")

It generated the .bin file, the .xml file and the .yaml file, which has the following content:

description: Ultralytics YOLOv10n model trained on D:\AI\process\all-bridges\data.yaml
author: Ultralytics
date: '2024-09-19T18:10:05.091451'
version: 8.2.74
license: AGPL-3.0 License (https://ultralytics.com/license)
docs: https://docs.ultralytics.com
stride: 32
task: detect
batch: 1
imgsz:
- 640
- 640
names:
  0: axle
  1: minivan
  2: pickup
  3: sedan
  4: suv
  5: truck
  6: tractor

Interesting enough, When I use either the pytorch ".pt" or onnx ".onnx" model, my program runs well processing all the video frames with no issues at all (but, I am using a relatively low edge device needing to make more use of the integrated GPU).

Just before I finished posting this comment, I upgraded "ultralytics" to version "8.2.101" and, I still encountered the same issue.

Below is the full error stack:

>py y10-tracking.py
Loading models\pt\2024-09-06-1-18PM-Y10\best_openvino_model for OpenVINO inference...
Using OpenVINO LATENCY mode for batch=1 inference...
...
inference_imageFrame_results = model.track(imageFrame, imgsz=640, persist=True, conf=Minimum_Acceptable_Score, max_det=10, stream_buffer=True) #, device=dml
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\model.py", line 602, in track
    return self.predict(source=source, stream=stream, **kwargs)
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\model.py", line 555, in predict
    return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream)
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\predictor.py", line 168, in __call__
    return list(self.stream_inference(source, model, *args, **kwargs))  # merge list of Result into one
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\torch\utils\_contextlib.py", line 36, in generator_context
    response = gen.send(None)
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\predictor.py", line 274, in stream_inference
    s[i] += self.write_results(i, Path(paths[i]), im, s)
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\predictor.py", line 334, in write_results
    string += f"{result.verbose()}{result.speed['inference']:.1f}ms"
  File "C:\Users\rgvdeveloper\Documents\programs\y_env\lib\site-packages\ultralytics\engine\results.py", line 663, in verbose
    log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "
KeyError: 7

[glenn-jocher]

@ezcsdeveloper it seems like the error is due to a mismatch in class indices. Ensure that the class indices in your OpenVINO model's YAML file match those in your code. If the issue persists, consider re-exporting the model and verifying the class names and indices. For further assistance, please refer to the Ultralytics documentation.

[udayhese96]

!yolo task=detect mode=train epochs=10 batch=10 plots=True
model='/content/-q/yolov10n.pt'
data='/content/Indian_Balanced_Dataset-2-3/data.yaml'

Error:-

/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py:733: FutureWarning: You are using torch.load with weights_only=False (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for weights_only will be flipped to True. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via torch.serialization.add_safe_globals. We recommend you start setting weights_only=True for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.
ckpt = torch.load(file, map_location="cpu")
New https://pypi.org/project/ultralytics/8.2.102 available 😃 Update with 'pip install -U ultralytics'
Ultralytics YOLOv8.1.34 🚀 Python-3.10.12 torch-2.4.1+cu121 CPU (Intel Xeon 2.20GHz)
engine/trainer: task=detect, mode=train, model=/content/-q/yolov10n.pt, data=/content/Indian_Balanced_Dataset-2-3/data.yaml, epochs=10, time=None, patience=100, batch=10, imgsz=640, save=True, save_period=-1, val_period=1, cache=False, device=None, workers=8, project=None, name=train, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/detect/train
Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/yolov10/Arial.ttf'...
100% 755k/755k [00:01<00:00, 648kB/s]
2024-09-27 13:23:28.707881: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2024-09-27 13:23:28.736500: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2024-09-27 13:23:28.743641: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
Overriding model.yaml nc=80 with nc=6

               from  n    params  module                                       arguments                     

0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2]
1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2]
2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True]
3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2]
4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True]
5 -1 1 9856 ultralytics.nn.modules.block.SCDown [64, 128, 3, 2]
6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True]
7 -1 1 36096 ultralytics.nn.modules.block.SCDown [128, 256, 3, 2]
8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True]
9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5]
10 -1 1 249728 ultralytics.nn.modules.block.PSA [256, 256]
11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
12 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
13 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1]
14 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
15 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
16 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1]
17 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2]
18 [-1, 13] 1 0 ultralytics.nn.modules.conv.Concat [1]
19 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1]
20 -1 1 18048 ultralytics.nn.modules.block.SCDown [128, 128, 3, 2]
21 [-1, 10] 1 0 ultralytics.nn.modules.conv.Concat [1]
22 -1 1 282624 ultralytics.nn.modules.block.C2fCIB [384, 256, 1, True, True]
23 [16, 19, 22] 1 863668 ultralytics.nn.modules.head.v10Detect [6, [64, 128, 256]]
YOLOv10n summary: 385 layers, 2709380 parameters, 2709364 gradients, 8.4 GFLOPs

Transferred 493/595 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/train', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py:276: FutureWarning: torch.cuda.amp.GradScaler(args...) is deprecated. Please use torch.amp.GradScaler('cuda', args...) instead.
self.scaler = torch.cuda.amp.GradScaler(enabled=self.amp)
train: Scanning /content/Indian_Balanced_Dataset-2-3/train/labels... 638 images, 0 backgrounds, 0 corrupt: 100% 638/638 [00:00<00:00, 1662.78it/s]
train: New cache created: /content/Indian_Balanced_Dataset-2-3/train/labels.cache
WARNING ⚠️ Box and segment counts should be equal, but got len(segments) = 272, len(boxes) = 1611. To resolve this only boxes will be used and all segments will be removed. To avoid this please supply either a detect or segment dataset, not a detect-segment mixed dataset.
/usr/local/lib/python3.10/dist-packages/albumentations/init.py:13: UserWarning: A new version of Albumentations is available: 1.4.16 (you have 1.4.15). Upgrade using: pip install -U albumentations. To disable automatic update checks, set the environment variable NO_ALBUMENTATIONS_UPDATE to 1.
check_for_updates()
/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py:191: UserWarning: Got processor for bboxes, but no transform to process it.
self._set_keys()
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))
val: Scanning /content/Indian_Balanced_Dataset-2-3/valid/labels... 183 images, 1 backgrounds, 0 corrupt: 100% 183/183 [00:00<00:00, 1577.27it/s]
val: New cache created: /content/Indian_Balanced_Dataset-2-3/valid/labels.cache
WARNING ⚠️ Box and segment counts should be equal, but got len(segments) = 15, len(boxes) = 365. To resolve this only boxes will be used and all segments will be removed. To avoid this please supply either a detect or segment dataset, not a detect-segment mixed dataset.
Plotting labels to runs/detect/train/labels.jpg...
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically...
optimizer: AdamW(lr=0.001, momentum=0.9) with parameter groups 95 weight(decay=0.0), 108 weight(decay=0.00046875), 107 bias(decay=0.0)
TensorBoard: model graph visualization added ✅
Image sizes 640 train, 640 val
Using 0 dataloader workers
Logging results to runs/detect/train
Starting training for 10 epochs...
Closing dataloader mosaic
/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py:191: UserWarning: Got processor for bboxes, but no transform to process it.
self._set_keys()
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

  Epoch    GPU_mem     box_om     cls_om     dfl_om     box_oo     cls_oo     dfl_oo  Instances       Size

0% 0/64 [00:00<?, ?it/s]
Traceback (most recent call last):
File "/usr/local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/usr/local/lib/python3.10/dist-packages/ultralytics/cfg/init.py", line 594, in entrypoint
getattr(model, mode)(**overrides) # default args from model
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/model.py", line 657, in train
self.trainer.train()
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py", line 213, in train
self._do_train(world_size)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py", line 363, in _do_train
for i, batch in pbar:
File "/usr/local/lib/python3.10/dist-packages/tqdm/std.py", line 1181, in iter
for obj in iterable:
File "/usr/local/lib/python3.10/dist-packages/ultralytics/data/build.py", line 49, in iter
yield next(self.iterator)
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py", line 630, in next
data = self._next_data()
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py", line 673, in _next_data
data = self._dataset_fetcher.fetch(index) # may raise StopIteration
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py", line 52, in fetch
data = [self.dataset[idx] for idx in possibly_batched_index]
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py", line 52, in
data = [self.dataset[idx] for idx in possibly_batched_index]
File "/usr/local/lib/python3.10/dist-packages/ultralytics/data/base.py", line 253, in getitem
return self.transforms(self.get_image_and_label(index))
File "/usr/local/lib/python3.10/dist-packages/ultralytics/data/augment.py", line 74, in call
data = t(data)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/data/augment.py", line 866, in call
new = self.transform(image=im, bboxes=bboxes, class_labels=cls) # transformed
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py", line 334, in call
self.preprocess(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py", line 368, in preprocess
p.preprocess(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 125, in preprocess
data = self.add_label_fields_to_data(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 185, in add_label_fields_to_data
encoded_labels = encoder.fit_transform(data[label_field])
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 60, in fit_transform
self.fit(y)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 48, in fit
unique_labels = sorted(set(y))
TypeError: unhashable type: 'numpy.ndarray'

Why did I get an error in the code above, even though it was running perfectly 2-3 days ago? The dataset shouldn't be the issue, as I'm using one from Roboflow.

[glenn-jocher]

@udayhese96 it seems the error is related to a recent update or change in the library dependencies. Please ensure all packages are up-to-date with pip install -U ultralytics albumentations. If the issue persists, consider checking the dataset format or reverting to a previous working version. For further assistance, visit our help page.

[Sudip241999]

  Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

0% 0/46 [00:02<?, ?it/s]
Traceback (most recent call last):
File "/usr/local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/cfg/init.py", line 249, in entrypoint
getattr(model, mode)(verbose=True, **overrides)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/engine/model.py", line 207, in train
self.trainer.train()
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/engine/trainer.py", line 183, in train
self._do_train(int(os.getenv("RANK", -1)), world_size)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/engine/trainer.py", line 284, in _do_train
for i, batch in pbar:
File "/usr/local/lib/python3.10/dist-packages/tqdm/std.py", line 1181, in iter
for obj in iterable:
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py", line 630, in next
data = self._next_data()
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py", line 673, in _next_data
data = self._dataset_fetcher.fetch(index) # may raise StopIteration
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py", line 52, in fetch
data = [self.dataset[idx] for idx in possibly_batched_index]
File "/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py", line 52, in
data = [self.dataset[idx] for idx in possibly_batched_index]
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/data/base.py", line 180, in getitem
return self.transforms(self.get_label_info(index))
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/data/augment.py", line 48, in call
data = t(data)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/yolo/data/augment.py", line 569, in call
new = self.transform(image=im, bboxes=bboxes, class_labels=cls) # transformed
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py", line 334, in call
self.preprocess(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/composition.py", line 368, in preprocess
p.preprocess(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 125, in preprocess
data = self.add_label_fields_to_data(data)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 185, in add_label_fields_to_data
encoded_labels = encoder.fit_transform(data[label_field])
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 60, in fit_transform
self.fit(y)
File "/usr/local/lib/python3.10/dist-packages/albumentations/core/utils.py", line 48, in fit
unique_labels = sorted(set(y))
TypeError: unhashable type: 'numpy.ndarray'
Sentry is attempting to send 1 pending events
Waiting up to 2 seconds
Press Ctrl-C to quit

how to fix this error?

[glenn-jocher]

@Sudip241999 it seems like the error is due to an unhashable type in the dataset. Please check your data loading and transformation steps to ensure that labels are correctly formatted as hashable types, such as strings or integers. If the issue persists, consider reviewing the data augmentation pipeline for any inconsistencies.

[Maronq]

I want to know the reason of attributeerro.

Why?
AttributeError: 'ObjectCounter' object has no attribute 'start_counting'

[Maronq]

Suddenly, this error occurred this morning.
Until last week, it was working, without errors.

[glenn-jocher]

@Maronq it seems like the ObjectCounter class is missing the start_counting method. Please check if the method is defined in your class or if there have been any recent changes to the codebase. If the issue persists, reviewing the class definition might help identify the problem.

[satan11122]

Detection accuracy metrics are typically applied to the entire validation set. I would like to know if there is a way to obtain detection accuracy metrics for individual images in the validation set.

[glenn-jocher]

@satan11122 to obtain detection accuracy metrics for individual images, you can modify the validation script to output metrics per image. This involves adjusting the evaluation loop to log results for each image separately. For detailed guidance, please refer to the Ultralytics documentation or community forums.

[Swetha4545]

Hi,could anyone please help me to choose which yolo model will be better for object detection for small objects like cotton from cotton field.

[glenn-jocher]

@Swetha4545 for detecting small objects like cotton, YOLOv8 or YOLOv11 models are recommended due to their enhanced capabilities and accuracy. You can experiment with different model sizes to find the best fit for your specific dataset and requirements. For more details, visit the Ultralytics documentation.

[GitHub00002]

During my use of YOLOv8, there is a data type conflict between the annotation and some of my Python 3.12. How can I solve this problem?

[glenn-jocher]

@GitHub00002 it seems you're encountering a data type conflict with YOLOv8 and Python 3.12. Ensure your annotation formats are compatible with the expected data types in YOLOv8. You might want to check the documentation for any specific requirements or consider using a different Python version if compatibility issues persist. For further assistance, please refer to the Ultralytics Help page.

[ljieke]

Why did I use yolo11 to train my own data set, and the trained model works well in image detection, but poorly in video detection?

[glenn-jocher]

@ljieke it sounds like the issue might be related to differences in frame processing or motion blur in videos. Consider adjusting the confidence threshold or using a higher frame rate. For more details, you can explore our documentation at https://docs.ultralytics.com/help/.

[mannyourfriend]

Hi, I'm training a few YOLO models on multiple computers. I have a dataset saved on a network drive, but i'd like to cache the dataset to speed the process up. My Ram is too low, so I'd like to use disk, but I'm having a new problem: The .cache file is created on the network drive, instead of locally. I read that you previously hadn't implemented anything to tell the computer where to cache, and was wondering if that was still the case.

Do you have any solutions, beyond just copying he entire dataset from the network onto the individual computers?

[mannyourfriend]

One other thing to add, I technically do have enough RAM to store the dataset, but when I try, I'm prevented because I don't have 50% extra storage on top of that. Could I adjust this number somewhere, to instead 20% so I don't get an error?

[glenn-jocher]

Currently, the caching location defaults to the dataset's directory, and there isn't an option to specify a different cache location. You might consider creating a symbolic link from the network drive to a local directory to manage the cache locally.

[mannyourfriend]

Ok. Also, I tweaked the RAM setting in code manually. Made it so "Safe Space" is 20% more memory than the dataset's size instead of 50%. I haven't run this to see if it works or if the computer crashes, is it worth a shot?

[glenn-jocher]

Modifying the RAM setting to reduce the "Safe Space" requirement from 50% to 20% could work, but it may increase the risk of running out of memory during training. It's worth testing, but monitor your system's performance closely to avoid crashes.

[MattCrBoom]

hf3

[glenn-jocher]

Thank you for reaching out. For comprehensive assistance with Ultralytics YOLO, please refer to our Help page where you'll find FAQs, contributing guides, and more. For further queries, feel free to use GitHub Issues or our official discussion forums.

[alejoherrera]

google colab

Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.8.0->ultralytics) (3.0.2)

ModuleNotFoundError Traceback (most recent call last)
in <cell line: 2>()
1 get_ipython().run_line_magic('pip', 'install ultralytics')
----> 2 import ultralytics
3 ultralytics.checks()

/usr/local/lib/python3.10/dist-packages/ultralytics/init.py in
4
5 import os
----> 6 import package
7
8 # Set ENV variables (place before imports)

ModuleNotFoundError: No module named 'package'

[kalpak25github]

!pip install git+https://github.com/ultralytics/ultralytics.git . Try with this

[glenn-jocher]

@kalpak25github if you encounter the ModuleNotFoundError after running !pip install ultralytics, try installing the latest development version using this command: !pip install git+https://github.com/ultralytics/ultralytics.git. This should resolve the issue with missing modules. Let me know if the problem persists!

[dcalvo-ollow]

Hi, when running an inference with YOLOv11 is it possible to not print [ 0: 512x640 1 lighted-area, 1 linear-pattern, 80.2ms
Speed: 5.1ms preprocess, 80.2ms inference, 1.0ms postprocess per image at shape (1, 3, 512, 640) ] ?
I've checked the inference arguments but i am not sure of seeing one to control this.

Thanks :)

[glenn-jocher]

@dcalvo-ollow to suppress the inference output in YOLOv11, set the verbose argument to False when running the model. For example:

results = model("path/to/image.jpg", verbose=False)

This will disable the printed inference details. Let me know if you have further questions!