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.

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

It looks like you're encountering a ValueError due to the discrepancy in lengths of the image_names and readings lists. This error occurs when these lists aren't the same length, causing the DataFrame creation to fail because it expects equal-length columns.

Please double-check that both image_names and readings have the same number of elements before you try to create the DataFrame. Here's a simple check you can add before creating the DataFrame:

if len(image_names) == len(readings):
    data = {'Image Name': image_names, 'Readings': readings}
    df = pd.DataFrame(data)
    df.to_excel('detections.xlsx', index=False)
else:
    print("Error: 'image_names' and 'readings' are not the same length!")

This code snippet will ensure that you only attempt to create the DataFrame when the lengths match, and it will help you catch mismatches early.

If you need any further assistance, feel free to ask! 😊 Happy coding! 🚀

[neemaaditi]

Thanks for the 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! 🚀

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

[benicio22]

I have this code here and an error. But for some reason it is not extracting all my frames. It should at least extract 15,000 of color frames and 15,000 depth because I did work before, but now it is not working anymore. I tested this code with different bag files and I am still having the same problem taht did not arrive frame with 5000... I increased time for 10000, but I am still having the same error.
import pyrealsense2 as rs
import cv2
import numpy as np
import os

Folder path containing the bag files

folder_path = r"D:\11-13-2023\DEPTH\INTEL_REALSENSE\ORIGINAL_DATA\FRONT_VIEW"

Get a list of all .bag files in the folder

bag_files = [file for file in os.listdir(folder_path) if file.endswith("20231113_070159.bag")]

Main loop to process bag files

for bag_file in bag_files:
# Configure pipeline settings
pipeline = rs.pipeline()
config = rs.config()
config.enable_device_from_file(os.path.join(folder_path, bag_file))

# Start the pipeline
pipeline.start(config)

# Create align object
align_to = rs.stream.color
align = rs.align(align_to)

try:
    frame_count = 0  # Variable to track the frame count

    while True:
        # Wait for frames
        frames = pipeline.wait_for_frames()

        # Align frames
        aligned_frames = align.process(frames)

        # Get aligned color and depth frames
        color_frame = aligned_frames.get_color_frame()
        depth_frame = aligned_frames.get_depth_frame()

        # Check if frames are valid
        if not color_frame or not depth_frame:
            continue

        # Convert frames to numpy arrays
        color_image = np.asanyarray(color_frame.get_data())
        depth_image = np.asanyarray(depth_frame.get_data())

        # Convert color image to BGR color space (or the desired color space)
        color_image_bgr = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)

        # Save color image as JPG
        color_filename = os.path.join(folder_path, f"{bag_file}_color_{frame_count}.jpg")
        cv2.imwrite(color_filename, color_image_bgr)

        # Save depth image as PNG (or any other format)
        depth_filename = os.path.join(folder_path, f"{bag_file}_depth_{frame_count}.png")
        cv2.imwrite(depth_filename, depth_image)

        print(f"Frame {frame_count} in {bag_file}: Color image and depth image saved.")
        frame_count += 1  # Increment the frame count

except KeyboardInterrupt:
    pass

# Stop the pipeline after processing each bag file
pipeline.stop()

But I am having this error: Traceback (most recent call last):
File "C:\Users\isabe\Documents\Cattle_2024_Luana\EXPORT_DEPTH_COLOR_IMAGES_FROM_BAG.py", line 27, in
frames = pipeline.wait_for_frames()
^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: Frame didn't arrive within 5000

[glenn-jocher]

Hey there! It looks like you are facing a timeout issue with the pipeline.wait_for_frames() method, which is quite common when reading from bag files that might not emit frames as expected.

One quick suggestion is to increase the timeout in the wait_for_frames() method to handle this more gracefully. You can specify the timeout in milliseconds directly within the method. For example:

# Extend the timeout to 10000 milliseconds
frames = pipeline.wait_for_frames(10000)

This gives the pipeline more time to wait for the next frame. If this does not solve the issue, you might also want to ensure that the bag file is not corrupted and is being read correctly, or that there are sufficient frames available as expected.

Let me know how it goes! 😊

[AekSW]

Is it possible to use ultralytics to find distance and speed of the vehicle in front when using car's dashcam?

[glenn-jocher]

@AekSW currently, Ultralytics YOLO models are designed for object detection, segmentation, and classification, but they do not natively support distance and speed estimation of objects such as vehicles from video input like a dashcam.

For distance and speed estimation, you would typically need additional data such as camera calibration parameters and object size estimates or use specialized techniques like optical flow, radar data integration, or other sensor fusion methodologies which are not part of the YOLO implementations.

That said, you can still use YOLO to detect vehicles and then apply additional algorithms to compute distance and speed based on other inputs and assumptions you may be able to make about the scene. Here’s a very basic example using detection results to feed into a hypothetical distance estimation function:

from ultralytics import YOLO

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

# Run detection
results = model('dashcam_video.mp4')

# Function to estimate distance (placeholder, implement based on your approach)
def estimate_distance(detection):
    # Placeholder logic to compute distance from detection data
    pass

# Assuming vehicle detections have been made
for result in results:
    if result.label == 'vehicle':  # Assuming 'vehicle' is a valid class label in your model
        distance = estimate_distance(result)
        print(f"Detected vehicle at distance: {distance}")

For actual implementation, you’d need to explore computer vision techniques like those mentioned earlier or consult with resources or experts specializing in telemetry or automotive AI solutions.

[menibl]

Hello
I need help I am using Yolov8 track/detect mode
I have to problems I am facing
1)the track id is changing for the same object if the object is moving
2) I want to save the video after analyzing cuted to 2 minutes each video if a format I can play (MP4)
Thank you all

[pderrenger]

Hello! It's great that you're using YOLOv8 for object tracking. Here are some insights on the issues you mentioned:

1. Stable Tracking IDs: The changing ID for the same object can be a bit tricky, but you can try improving the tracker's stability by tuning the parameters in your chosen tracker configuration. Adjust the iou_threshold or experiment with different trackers like ByteTrack or BoT-SORT for potentially better performance with moving objects.

2. Saving the Video in Chunks: To save the analyzed video cut into 2-minute segments, you can use the following approach:

import cv2
from ultralytics import YOLO

model = YOLO('yolov8n.pt')
cap = cv2.VideoCapture('input_video.mp4')
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fps = int(cap.get(cv2.CAP_PROP_FPS))
width, height = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
segment_length = 2 * 60 * fps  # 2 minutes

count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    results = model.track(frame, persist=True)
    if count % segment_length == 0:
        out = cv2.VideoWriter(f'output_segment_{count // segment_length + 1}.mp4', fourcc, fps, (width, height))
    out.write(results.render())
    count += 1
    if count % segment_length == 0:
        out.release()

cap.release()
out.release()

This script will process your video, segment it every 2 minutes, and save each segment to a new file. If there is any more specific functionality or different issue you're encountering, feel free to ask! 🚀

[ijas9118]

from ultralytics import YOLO
from ultralytics.solutions import heatmap
import cv2

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.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))

Video writer

video_writer = cv2.VideoWriter("heatmap_output.avi",
cv2.VideoWriter_fourcc(*'mp4v'),
fps,
(w, h))

classes_for_heatmap = [0, 2] # classes for heatmap

Init heatmap

heatmap_obj = heatmap.Heatmap()
heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
imw=w,
imh=h,
view_img=True,
shape="circle",
classes_names=model.names)

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=classes_for_heatmap)

im0 = heatmap_obj.generate_heatmap(im0, tracks)
video_writer.write(im0)

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

The output video that is saved is in binary. Hence, I cannot use it to send it to my react app front end and play it. Can you give me a simple code + react template to render the output video?

[pderrenger]

It looks like the issue you're encountering with the binary output of your saved video might be because of the video codec used in your VideoWriter configuration. For compatibility with web applications, such as a React frontend, it's generally a good idea to ensure the output is in a web-friendly format like .mp4.

Here's a revised line of code for the VideoWriter that specifically sets the codec to H264, which is widely supported on web platforms:

video_writer = cv2.VideoWriter("heatmap_output.mp4",
                               cv2.VideoWriter_fourcc(*'H264'),
                               fps,
                               (w, h))

For incorporating the video into your React app, you can use a simple video tag in your JSX as follows:

<video width="320" height="240" controls>
  <source src="path/to/heatmap_output.mp4" type="video/mp4">
  Your browser does not support the video tag.
</video>

Make sure the src attribute points to the correct location of your video file on your server or hosting environment.

Let me know if this resolves your issue or if there's anything else I can help you with! 😊

[shar486]

Hello, I would like to ask whether the following code can be directly used in the software by simply calling it. The AGPL agreement will not involve the whole software open source:
from ultralytics import YOLO
model = YOLO("yolov8n-pose.pt")
results = model.predict(source=image_jpg)

[glenn-jocher]

Hello! Thanks for reaching out. Regarding your question, it's important to note that the usage of any Ultralytics software, models, or code under the AGPL-3.0 requires that the whole project be open-sourced if it's distributed. This includes modifications, additions, or any software that uses our AGPL-licensed components.

So, in your case, using the code snippet as part of a software that is not open source would not comply with the AGPL-3.0 license. If your project is commercial or you want to keep it proprietary, you would need an Ultralytics Enterprise License.

Feel free to contact us if you need more information about obtaining an enterprise license! 🌟

[wasiur32]

hello sir if I use uultralytics package which is freely on the internet for my start-up for product development, should I need to pay for this

[glenn-jocher]

Hello! For using the Ultralytics software, including the YOLO models for product development in a startup, you'll need an Ultralytics Enterprise License. The open-source AGPL-3.0 license lets you use the models freely if you also open-source your project under the same license. However, for commercial product development, an Enterprise License is required to comply with the licensing terms without the need to open source your project.

If you have more questions or need to acquire an Enterprise License, please feel free to reach out to us. We're here to help! 😊

[supersrh]

I tested the provided code 'yolo segment train data=crack-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640'
it failed with:
Starting training for 100 epochs...

  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  1/100      3.79G      2.033      4.381       3.45       2.01         37        640:   0%|          | 1/233 [00:05Exception in thread Thread-28 (plot_images):

Traceback (most recent call last):
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\threading.py", line 1045, in _bootstrap_inner
self.run()
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\threading.py", line 982, in run
self._target(*self._args, **self._kwargs)
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\site-packages\ultralytics\utils\plotting.py", line 898, in plot_images
im = np.asarray(annotator.im).copy()
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
numpy.core._exceptions._ArrayMemoryError: Unable to allocate 10.5 MiB for an array with shape (1920, 1920, 3) and data type uint8
1/100 4.54G 2.245 4.518 3.552 2.058 41 640: 1%|▏ | 3/233 [00:14Exception in thread Thread-30 (plot_images):
Traceback (most recent call last):
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\threading.py", line 1045, in _bootstrap_inner
self.run()
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\threading.py", line 982, in run
self._target(*self._args, **self._kwargs)
File "D:\ProgramData\anaconda3\envs\Ultralytics\Lib\site-packages\ultralytics\utils\plotting.py", line 806, in plot_images
masks = masks.cpu().numpy().astype(int)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
numpy.core._exceptions._ArrayMemoryError: Unable to allocate 1.56 MiB for an array with shape (16, 160, 160) and data type int32

[supersrh]

yes ur right. The images in the crack-seg example are in 416*416. I changed the imgsz to 416 and it was solved.

[glenn-jocher]

Great to hear that adjusting the imgsz to 416 solved your issue! Aligning the training image size with your dataset's dimensions can indeed make a significant difference. If you have any more questions or need further assistance down the road, don’t hesitate to reach out. Happy coding! 😊🚀

[supersrh]

Thanks. Actually I'm still not clear about the meaning of imgsz. I find that the imgsz can be set as two-dimension like imgsz (800, 600), but what does it mean when only given one value? like imgsz 800?

[glenn-jocher]

Hello! 👋

Great question regarding imgsz. When you set imgsz with a single value like imgsz=800, it means that both the width and height of the images used during processing (training, validation, or inference) will be resized to 800x800 pixels, making the image square.

However, if you specify it as two values like imgsz=(800, 600), it means the images will be resized to 800 pixels wide by 600 pixels high.

This flexibility allows you to match the input size to your model's requirements or to optimize for computational efficiency depending on the aspect ratio of your original images.

Hope this clarifies things! Let me know if you have any more questions. 😊

[supersrh]

THANKS！
I occasionally saw a comment at the website (https://docs.ultralytics.com/help/) from 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.

Further more I found it seems that the final imgsz would be set as an integral multiple of the stride (may be 32 by default). For example I set imgsz 600 and the running code told me that it will be set to be 608 which is 19 times 32.

[ijas9118]

Can we do line counting for multiple videos using threading?

[ijas9118]

import threading
import cv2
from ultralytics import YOLO
from ultralytics.solutions import object_counter

def run_tracker_in_thread(filename, model, file_index):
    """
    Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.
    This function captures video frames from a given file or camera source and utilizes the
    YOLOv8 model for object tracking and counting using the line counter method.
    The function runs in its own thread for concurrent processing.

    Args:
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
        model (obj): The YOLOv8 model object.
        file_index (int): An index to uniquely identify the file being processed, used for display purposes.

    Note: Press 'q' to quit the video display window.
    """
    cap = cv2.VideoCapture(filename)
    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))
    line_points = [(20, 400), (1080, 400)]  # Define line points

    # Video writer
    video_writer = cv2.VideoWriter(f"count_line_{file_index}.avi", cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))

    # Init Object Counter
    counter = object_counter.ObjectCounter()
    counter.set_args(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(f"Video {file_index} frame is empty or video processing has been successfully completed.")
            break

        tracks = model.track(im0, persist=True, show=False)
        im0 = counter.start_counting(im0, tracks)
        video_writer.write(im0)
        print(f"File {file_index}: {counter.class_wise_count}")

        key = cv2.waitKey(1)
        if key == ord('q'):
            break

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

# Load the models
model1 = YOLO('yolov8n.pt')
model2 = YOLO('../runs/detect/train/weights/best.pt')

# Define the video files for the trackers
video_file1 = "../videos/cars2.mp4"  # Path to video file, 0 for webcam
video_file2 = '../videos/sample_video.mp4'  # Path to video file, 0 for webcam, 1 for external camera

# Create the tracker threads
tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

# Start the tracker threads
tracker_thread1.start()
tracker_thread2.start()

# Wait for the tracker threads to finish
tracker_thread1.join()
tracker_thread2.join()

I tried using the line counter method, but it crashes after detecting few frames. Is there any other way?

[glenn-jocher]

@ijas9118 hello! It sounds like you're experiencing issues with the line counting after a few frames. If the approach you described crashes consistently, I'd recommend looking into potential memory leaks or an excessive build-up of unmanaged resources within your threading environment. Here are a few troubleshooting steps you might consider:

1. Close Resources Properly: Ensure that all resources such as video captures and writers are closed properly within each thread after processing. Use cap.release(), video_writer.release(), and cv2.destroyAllWindows() effectively.

2. Error Handling: Introduce error handling within the loop to catch any exceptions that might hint at what causes the crash, which could be useful for debugging.

3. Reduce CPU Load: Check if the CPU load is exceptionally high leading to crashes, and consider reducing the frame rate or resolution if needed.

4. Profile the Memory: Use tools to profile memory usage and identify if there's a specific point or operation causing memory spikes.

5. Update or Installation Check: Verify that all required libraries are updated and correctly installed, especially cv2 and ultralytics.

If these steps don't help, could you perhaps share more details or error logs? That would be very helpful in diagnosing the problem more accurately. Good luck, and I hope this helps!

[1203mueed]

How can I use augmentation? And what will be the training code? Please give me an example how can I use Mosaic augmentation.

[1203mueed]

Thank you! What are the other types of augmentation available? Also, is there any built in GANs to generate synthetic images from the dataset?

[pderrenger]

@1203mueed hi there!

For augmentations, YOLOv8 supports a variety of options such as Mosaic, MixUp, RandomPerspective, and more, which can all be configured in your dataset YAML under the augment section.

Currently, YOLOv8 does not include built-in Generative Adversarial Networks (GANs) for generating synthetic images directly within the model's training framework. However, you can certainly use external tools to create synthetic datasets and then train YOLOv8 with those images.

If you need further details or have any more questions, feel free to ask. Happy training! 😊

[pderrenger]

Hi there!

For augmentations, YOLOv8 supports a variety of options such as Mosaic, MixUp, RandomPerspective, and more. You can configure these in your dataset YAML file under the augment section.

Currently, YOLOv8 does not include built-in Generative Adversarial Networks (GANs) for generating synthetic images directly within the model's training process. However, you can certainly use external GAN models to create synthetic datasets and then train YOLOv8 on these images as part of your data augmentation strategy.

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

[1203mueed]

Thank You

[pderrenger]

@1203mueed hello!

Thank you for reaching out! If you have any specific questions or need further information, feel free to browse our Help page where you can find FAQs, contribution guides, and more. If there's something more specific you're dealing with, please don't hesitate to let us know here on GitHub. We're here to help!

Happy coding! 😊

[1203mueed]

I want to pass segmentation as feature during training. So, I want to use SAM by facebook. I'm training the model using YOLOV9. Can you please tell in which file, I have to add the code to pass this feature?

[pderrenger]

Hi there! 👋

To integrate Facebook's SAM (Segment Anything Model) during the training of a YOLOv9 model, you'll need to modify the dataset loading and training pipeline to handle the segmentation masks along with the usual image and labels. This usually requires changes in the following files:

• Dataset Handling: Modify the dataset classes (possibly located in datasets.py or a similar file) to include loading and transforming the segmentation masks.

• Training Script: In the main training script (such as train.py), ensure that the segmentation masks are passed alongside images and labels during the forward pass of the model.

This is a high-level guideline, and specific implementations might vary depending on how SAM is structured and your particular setup. Make sure to adjust the model's architecture and loss functions as needed to incorporate segmentation as a feature.

If you need a more specific example or run into any trouble, don't hesitate to ask for help! 😊 Happy coding!

[1203mueed]

I started training model on YOLOV9. But suddenly my PC shuts down after 10 epochs. Is there any way I can resume training from 10 epochs?

[1203mueed]

I'm using this way:
from ultralytics import YOLO

Load your model

model = YOLO('runs/detect/train22/weights/last.pt')

The main guard

if name == 'main':
# Train your model
results = model.train(data='config.yaml', epochs=100)
Is this okay?

[glenn-jocher]

@1203mueed yes, your code for loading the model and commencing training looks correct. Just make sure your config.yaml accurately reflects the paths and settings for your dataset. Good luck with your training! If you encounter any issues, feel free to reach out. Happy coding! 😊👍

[1203mueed]

i have trained a model using yolov9. Now I have a validation dataset. I want to predict the images and calculate the mAP50 and mAP50-95 score. How can I do that? Also, how can I extract the predicted bounding boxes?

[glenn-jocher]

@1203mueed hello!

To evaluate your YOLOv9 model on the validation dataset and calculate the mAP50 and mAP50-95 scores, you can use the val mode in the Ultralytics framework. Here's a quick example of how you can do this using the CLI:

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

This command will automatically calculate and display the mAP scores for your model.

For extracting the predicted bounding boxes, you can use the predict mode. Here's how you can do it and save the results:

yolo predict model=path/to/your/yolov9_model.pt source=path/to/validation/images --save-txt

This will save the bounding boxes in a .txt format in the output directory, where each line in the text files corresponds to a detected object and includes class ID, x_center, y_center, width, and height, all normalized to the image size.

I hope this helps! Let me know if you have any more questions. 😊

[talha660033]

Hi @glenn-jocher
I have a question regarding the model training, I don't know what I'm doing wrong, I have manually annotated a dataset of different classes, following are the stats of the labels:
telephone: 65013
complaint-box: 70000
cash: 43054
person: 70000
trash: 70000
atm-card: 3505
helmet: 14835
atm: 25
Now when I am training yolov8n model, it doesn't give the required results as expected. the annotations are correct, yet It doesn't detect most of the classes.

[glenn-jocher]

Hi there! It looks like you're experiencing issues with class imbalance in your dataset, which is common when some classes have significantly more examples than others. This can affect the model's ability to learn less represented classes effectively.

A quick tip is to try using techniques like class weights or oversampling the under-represented classes during training. You can adjust the --img-weights flag in your training command to help the model pay more attention to rarer classes.

Here's a simple example of how you might adjust your training command:

yolo train data=your_dataset.yaml model=yolov8n.pt --img-weights

This should help improve detection performance across classes with fewer samples. For more detailed strategies on handling class imbalance, you might find our FAQ section helpful. Good luck! 🚀

[talha660033]

after running the command yolo task=detect mode=train data=data.yaml model=yolov8n.pt epochs=10 verbose=True patience=6 imgsz=640 cls=0.5 save=True save_period=1 val=True plots=True profile=True optimizer=AdamW --img-weights

I am getting this:
WARNING ⚠️ '--img-weights' does not require leading dashes '--', updating to 'img-weights'.
Traceback (most recent call last):
File "/home/all/.local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/home/all/.local/lib/python3.10/site-packages/ultralytics/cfg/init.py", line 498, in entrypoint
check_dict_alignment(full_args_dict, {a: ""})
File "/home/all/.local/lib/python3.10/site-packages/ultralytics/cfg/init.py", line 308, in check_dict_alignment
raise SyntaxError(string + CLI_HELP_MSG) from e
SyntaxError: 'img-weights' is not a valid YOLO argument.

[glenn-jocher]

Hi there! It looks like there's a small syntax issue in your command. The img-weights argument should not have leading dashes. Here's the correct way to include it in your command:

yolo task=detect mode=train data=data.yaml model=yolov8n.pt epochs=10 verbose=True patience=6 imgsz=640 cls=0.5 save=True save_period=1 val=True plots=True profile=True optimizer=AdamW img-weights

Just remove the dashes before img-weights, and you should be good to go! Let me know if you need any more help. Happy training! 🚀

[mayurkatre18]

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format='tflite')'''

Hi, I have to export model into tflite format but the error I'm getting is as given below.

TensorFlow SavedModel: export failure ❌ 19.1s: generic_type: cannot initialize type "StatusCode": an object with that name is already defined

ImportError Traceback (most recent call last)
in <cell line: 4>()
2
3 model = YOLO("/content/runs/segment/train/weights/best.pt")
----> 4 model.export(format='tflite')

11 frames
/usr/local/lib/python3.10/dist-packages/tensorflow_lite_support/python/task/vision/core/tensor_image.py in
17
18 from tensorflow_lite_support.python.task.vision.core import color_space_type
---> 19 from tensorflow_lite_support.python.task.vision.core.pybinds import image_utils
20
21

ImportError: generic_type: cannot initialize type "StatusCode": an object with that name is already defined.

Please give suggestion on this.

[glenn-jocher]

Hi there! It looks like you're encountering a conflict with TensorFlow's type definitions when trying to export your YOLO model to TFLite format. This issue might be due to multiple imports of TensorFlow in different parts of your project or dependencies that redefine the same object.

A potential solution is to isolate the TensorFlow import and ensure it's done in a clean environment. Here’s a quick suggestion:

1. Try creating a new Python environment (using conda or venv).
2. Install only the necessary packages (ultralytics and tensorflow).
3. Run your export code in this clean environment.

Here's how you can create and activate a new environment with conda:

conda create -n myenv python=3.8
conda activate myenv
pip install ultralytics tensorflow

Then, try running your export code again. If the problem persists, please provide more details, and we can explore further solutions! 🚀

[mayurkatre18]

Yes I have install necessary packages only. And I'm training this model on google collab so it is clear environment only. Help me with this.

[talha660033]

@glenn-jocher
after running the command yolo task=detect mode=train data=data.yaml model=yolov8n.pt epochs=10 verbose=True patience=6 imgsz=640 cls=0.5 save=True save_period=1 val=True plots=True profile=True optimizer=AdamW --img-weights

I am getting this:
WARNING ⚠️ '--img-weights' does not require leading dashes '--', updating to 'img-weights'.
Traceback (most recent call last):
File "/home/all/.local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/home/all/.local/lib/python3.10/site-packages/ultralytics/cfg/init.py", line 498, in entrypoint
check_dict_alignment(full_args_dict, {a: ""})
File "/home/all/.local/lib/python3.10/site-packages/ultralytics/cfg/init.py", line 308, in check_dict_alignment
raise SyntaxError(string + CLI_HELP_MSG) from e
SyntaxError: 'img-weights' is not a valid YOLO argument.

[glenn-jocher]

Hi @talha660033! It looks like the issue is with the img-weights argument. In the current version of the Ultralytics YOLO CLI, img-weights is not a recognized argument, which is why you're seeing the syntax error.

If you're trying to use image weights for balancing training on a dataset with class imbalance, you might need to implement this functionality manually in your training loop or adjust the dataset preprocessing.

For any further customization or clarification, please refer to our documentation or consider opening an issue on our GitHub page if you believe this feature should be supported. Happy coding! 🚀

[Me3ue]

I want to use Intel extension for pytorch on yolov8, how should I modify the code?

[glenn-jocher]

To integrate the Intel extension for PyTorch with YOLOv8, you'll need to ensure that your environment is set up with the necessary dependencies for the Intel extension. After setting up, you can modify the PyTorch device settings in your YOLOv8 code to utilize Intel's optimizations.

For specific code modifications, you might need to adjust the device initialization to ensure it leverages the Intel extension. This typically involves specifying the use of MKL-DNN or oneDNN in your PyTorch scripts, which are part of Intel's optimizations for deep learning.

If you encounter any issues or need further assistance, please feel free to open an issue on our GitHub page with details, and we'll be happy to help! 🚀

[Me3ue]

As a novice at deep learning I have no idea how to adjust the source code to achieve my purpose. I wonder if I could just use "intel_extension_for_pytorch.optimize( )" to optimize the training process. If so, where should I insert the statement? If not, what should I do? I would appreciate it if you could show me the modified code!

[glenn-jocher]

Hello!

Great question! To use the Intel extension for PyTorch to optimize your YOLOv8 training process, you can indeed use intel_extension_for_pytorch.optimize(). This function should be inserted right after importing PyTorch and before any significant computation or model initialization occurs.

Here’s a simple way to integrate it into your YOLOv8 setup:

import torch
import intel_extension_for_pytorch as ipex

# Optimize the default CPU settings
model = model.to(ipex.DEVICE)

# Now proceed with your model training or inference

Make sure to install the Intel extension for PyTorch first and verify that your system supports it. If you run into any issues or have more questions, feel free to ask. We're here to help!

Happy coding! 🚀