modes/predict/

[giscus[bot]]

modes/predict/

Discover how to use YOLOv8 predict mode for various tasks. Learn about different inference sources like images, videos, and data formats.

https://docs.ultralytics.com/modes/predict/

[soapboss]

thx, its amazing

[pderrenger]

@soapboss you're welcome! If you have any more questions or need further assistance, feel free to ask. Happy to help! 😊🚀

[jwmetrifork]

Can we set different confidences for different classes? It would be a nice addition.

[pderrenger]

@jwmetrifork currently, YOLOv8 does not support setting different confidence thresholds for different classes directly through the model's configuration or command-line arguments. The confidence threshold is a global setting that applies to all classes equally.

However, you can implement custom post-processing logic in Python after running predictions with the model. Here's a basic example of how you might apply different confidence thresholds for different classes after obtaining the results:

from ultralytics import YOLO

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

# Run inference on an image
results = model('bus.jpg')

# Define custom confidence thresholds for each class (example)
custom_conf_thresholds = {
    0: 0.5,  # Class ID 0 with 0.5 confidence
    1: 0.3,  # Class ID 1 with 0.3 confidence
    # Add more classes and thresholds as needed
}

# Filter results based on custom confidence thresholds
filtered_boxes = []
for box in results[0].boxes:
    class_id = int(box.cls)
    if box.conf >= custom_conf_thresholds.get(class_id, 0.25):  # Default threshold if class ID not in dict
        filtered_boxes.append(box)

# Do something with the filtered results
# ...

In this example, custom_conf_thresholds is a dictionary where keys are class IDs and values are the desired confidence thresholds for those classes. After running inference, we loop through the detected boxes and filter them based on these custom thresholds.

If you need this functionality often, consider suggesting it as a feature request on the YOLOv8 GitHub repository. The maintainers and community can discuss the feasibility and potential implementation of such a feature. 🚀

[jwmetrifork]

Thanks for answering. Yeah, I do something similar also. I will look into suggesting it as a feature

[pderrenger]

@jwmetrifork you're welcome! Custom post-processing like you're doing is a great way to tailor the model's output to your specific needs. If you feel that different confidence thresholds for different classes would be a valuable addition to YOLOv8, definitely consider suggesting it as a feature request on the GitHub repository. Your input could help improve the tool for everyone. If you need any assistance with the feature request or have further questions, feel free to reach out. Happy coding! 😊👨‍💻

[adbcode]

Can you please share more details on the retina_masks parameter in model.predict() method?

I understand that by default we receive 160x160 masks in segment models, but what does setting the above True do?

[pderrenger]

@adbcode certainly! The retina_masks parameter in the model.predict() method is used when performing inference with segmentation models. By default, segmentation masks are produced at a lower resolution (160x160) to balance between performance and speed. These masks are then upscaled to the original image size during post-processing.

When you set the retina_masks parameter to True, the model will generate high-resolution segmentation masks that match the original image size. This can be particularly useful when fine details in the segmentation masks are important for your application, as it provides more precise and detailed mask outputs.

However, it's important to note that using retina_masks=True may result in slower inference times due to the increased computational cost of generating higher-resolution masks. Therefore, you should consider the trade-off between mask resolution and inference speed based on your specific requirements.

Here's an example of how to use the retina_masks parameter:

from ultralytics import YOLO

# Load a pretrained segmentation model
model = YOLO('yolov8n-seg.pt')

# Run inference with high-resolution masks
results = model.predict('image.jpg', retina_masks=True)

In this example, the segmentation masks returned in the results object will be at the same resolution as the input image, providing more detailed segmentation results.

[adbcode]

Hi @pderrenger !

Thanks for a quick response.

I noticed that the trained model works on images with larger resolution than the imgsz parameter set during training. As per my understanding it means that during prediction the image is resized to this value before inference.

So to confirm, will the masks be created in imgsz resolution instead of 160x160 in this case or the resolution of the original image?

Regardless, I now understand that we can have more precise masks with this property.

[pderrenger]

Hi there! 👋

Yes, during prediction, if the imgsz parameter is set, the input image is resized to this value before inference. The masks are then created at the imgsz resolution divided by 4, unless retina_masks=True is used, which generates masks at the original image resolution for more precise (but slower) segmentation.

Hope that clarifies it! If you have any more questions, feel free to ask. 😊

[goshua13]

Hi, I am trying to do a simple yolo model and every time I try predicting it doesn't detect anything. Here is what I am doing. I am. downloading this dataset and then trying to train a model on it and then once its trained I am trying to predict with it. I pasted all of my code so that you can replicate.
I've been trying this for days now and don't know what I am doing wrong. I know it works because when I do it with the terminal commands on google collab it predicts the images just fine. Thanks in advance!

https://universe.roboflow.com/damage-4yhkc/damaged-bchyj/dataset/5/download

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_KEY")
project = rf.workspace("damage-4yhkc").project("damaged-bchyj")
dataset = project.version(5).download("yolov8")

model = YOLO('yolov8n-seg.pt') # build from YAML and transfer weights
results = model.train(data='config.yaml', task='segment' ,epochs=30, imgsz=640, device='mps', conf=.3, iou=.1)

#Predict
model = YOLO("runs/segment/train/weights/last.pt")
model.predict(conf=0.7, iou=.05, source='Damaged-5/test/images/dji_fly_20230916_092746_879_1694878079597_photo_optimized_jpg.rf.dbd81f856a2a92d8b98214d491055290.jpg')

[pderrenger]

@goshua13 hello! It seems like you've put in a lot of effort into getting your YOLO model to predict correctly. If it's working in Google Colab but not in your local setup, there might be an issue with the environment or the way the model is being loaded for prediction.

Here are a few things you can check:

1. Ensure that your local environment has all the necessary dependencies installed and is similar to the Colab environment where it works.
2. Verify that the path to the weights file in YOLO("runs/segment/train/weights/last.pt") is correct and accessible.
3. Check if the image path is correct and the image is being read properly.
4. Make sure that the confidence (conf) and IoU (iou) thresholds are set appropriately for prediction. Sometimes, if conf is too high, it might not detect anything.

If you're still facing issues, consider sharing the error messages or the behavior you're observing. This can provide more context for troubleshooting. Also, you can refer to the Ultralytics YOLOv8 documentation for more detailed guidance on predictions. Keep experimenting, and don't hesitate to reach out to the community for more specific advice!

[goshua13]

Awesome thank you, I am trying to save each image when I predict, and right now I am just using the save_crop=True, and its working great the only thing is that It doesn't save the metadata of the original image. I need the metadata from the original image to be saved for each cropped image. Is there a way to do this?

[pderrenger]

Hey there! 👋

Great to hear that save_crop=True is working well for you! To retain the original image metadata in each cropped image, you might need to handle this manually as the current functionality doesn't include metadata copying.

Here's a quick Python snippet using PIL that you can use after saving your cropped images:

from PIL import Image

# Load the original image and its metadata
original = Image.open('path/to/original/image.jpg')
metadata = original.info

# Load the cropped image
cropped = Image.open('path/to/cropped/image.jpg')

# Save the cropped image with the original metadata
cropped.save('path/to/save/cropped_with_metadata.jpg', **metadata)

This will copy the metadata from the original image to the cropped one. Just loop through your cropped images and apply this snippet to each. Hope this helps! 😊

Let me know if you need any more assistance. Happy coding!

[goshua13]

great! thank you!

[pderrenger]

Hey, thanks for reaching out! 🌟

For saving cropped images with the original metadata, you might consider a post-processing step where you copy the metadata from the original images to the cropped ones after prediction. This isn't handled by default in YOLOv8, but you can use libraries like PIL or piexif to transfer EXIF data.

Here's a quick example using piexif:

import piexif

# Load metadata from the original image
original_metadata = piexif.load('original_image.jpg')

# Copy metadata to the cropped image
piexif.insert(piexif.dump(original_metadata), 'cropped_image.jpg')

Just loop this for each cropped image. Hope this helps and happy coding! 😊👨‍💻

[teengineer]

Hello if i want to know these pixel coordinates represent which object, What should i do? For example this is my code

from ultralytics import YOLO

# Load a pretrained YOLOv8n-seg Segment model
model = YOLO('yolov8n-seg.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.masks.xy)  # print the Masks object containing the detected instance masks

And this code give to me the pixel coordinates of objects so how can i learn which coordinate represents which object?

[pderrenger]

Hey there! 👋 To find out which object corresponds to a particular set of pixel coordinates, you can check the cls attribute of the boxes object, which gives you the class IDs. Here's how you can modify your code to print the class names along with the mask coordinates:

from ultralytics import YOLO

# Load a pretrained YOLOv8n-seg Segment model
model = YOLO('yolov8n-seg.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    for i, mask in enumerate(r.masks.xy):
        class_id = r.boxes.cls[i].item()  # Get class ID for each mask
        class_name = r.names[class_id]  # Convert class ID to class name
        print(f"Object: {class_name}, Mask Coordinates: {mask}")

This will print out the class name for each set of mask coordinates. Hope this helps! 😊

[OmarKhaled0K]

With that code :

from ultralytics import YOLO

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

# Run batched inference on a list of images
results = model(['frame_1147.jpg','frame_2527.jpg'],save=True,save_txt=True)  # return a list of Results objects

    
# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bbox outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    

it print that results:
image 1/1 /content/frame_1147.jpg: 384x640 1 person, 1 dog, 1 couch, 1 potted plant, 1 remote, 324.9ms
but when printing probs it print None , why probs always contain None even if object detected

[glenn-jocher]

Hey there! 👋 It looks like you're trying to access the probs attribute for classification probabilities, but you're using a detection model (yolov8n.pt). The probs attribute is specific to classification tasks and will be None for detection models, which is why you're seeing None when you print it.

Detection models like yolov8n.pt will provide you with bounding boxes (boxes), objectness scores (conf), and class IDs (cls) for detected objects. If you want to perform classification and get probabilities, you'll need to use a classification model like yolov8n-cls.pt. Here's how you can do it:

from ultralytics import YOLO

# Load a classification model
model = YOLO('yolov8n-cls.pt')  # pretrained YOLOv8n classification model

# Run inference on images
results = model(['frame_1147.jpg', 'frame_2527.jpg'])

# Process results list
for result in results:
    probs = result.probs  # Probs object for classification outputs
    print(probs.top5)  # Print top-5 class probabilities

Hope this clears things up! 😊 Let me know if you have any other questions.

[mudassir659]

how can we count total number of objects in the set of images after training the model?

[glenn-jocher]

Hey there! 👋 To count the total number of objects across a set of images after training your model, you can use the predict mode to process your images and then sum up the detections. Here's a quick example using Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO('path/to/your/trained_model.pt')

# List of images to run inference on
images = ['image1.jpg', 'image2.jpg', ...]

# Run inference
results = model(images)

# Count total objects
total_objects = sum(len(result.boxes) for result in results)
print(f'Total objects detected: {total_objects}')

This will give you the total count of objects detected across all your images. Happy counting! 😊

[mudassir659]

Thank you so much for your response. I appreciate it. I want to know can we use this code for directory because I have 760 images in the directory I want count the total predicted boxes all in once. Thanks

…

On Tue, Feb 13, 2024, 9:55 PM Glenn Jocher ***@***.***> wrote: Hey there! 👋 To count the total number of objects across a set of images after training your model, you can use the predict mode to process your images and then sum up the detections. Here's a quick example using Python: from ultralytics import YOLO # Load your trained modelmodel = YOLO('path/to/your/trained_model.pt') # List of images to run inference onimages = ['image1.jpg', 'image2.jpg', ...] # Run inferenceresults = model(images) # Count total objectstotal_objects = sum(len(result.boxes) for result in results)print(f'Total objects detected: {total_objects}') This will give you the total count of objects detected across all your images. Happy counting! 😊 — Reply to this email directly, view it on GitHub <#7932 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BAHRMJFIOOEU34WCWMTYWELYTNWFDAVCNFSM6AAAAABCTDRDM6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4DINJUGA2TM> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

@mudassir659 absolutely, you can use YOLOv8 to process a directory with multiple images and count the total predicted boxes. Here's a simple way to do it using Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO('path/to/your/trained_model.pt')

# Run inference on the directory
results = model('path/to/your/directory', stream=True)  # Use stream=True for efficiency

# Count total boxes
total_boxes = sum(len(result.boxes) for result in results)
print(f'Total predicted boxes: {total_boxes}')

This code will iterate over all images in the specified directory, perform predictions, and tally up the total number of detected boxes. Let me know if you need any more help! 😊👍

[vonzo]

If i want to run predictions on several images at once, I shoumd use a tensor as
BCHW format with RGB channels float32 (0.0-1.0). is there a way to make this work if my images don't have the same size and also not the same ratio?

[glenn-jocher]

Hey there! 👋

For running predictions on multiple images of varying sizes and aspect ratios, you can pad each image to the same size or use the rect argument during training for rectangular inference. Here's a quick example of how you can pad your images to the same size:

import torch
from PIL import Image

# Load your images
images = [Image.open(path) for path in ['image1.jpg', 'image2.jpg']]

# Pad images to the same size
max_size = tuple(max(sizes) for sizes in zip(*[img.size for img in images]))
padded_images = [torch.nn.functional.pad(torch.from_numpy(np.array(img)), 
                 (0, max_size[0] - img.size[0], 0, max_size[1] - img.size[1]), 
                 mode='constant', value=0) for img in images]

# Stack images into a single tensor
input_tensor = torch.stack(padded_images).float() / 255.0  # Normalize to [0, 1]

Now input_tensor is in BCHW format and ready for inference with YOLOv8. Keep in mind that padding might affect the aspect ratio, so you might want to adjust your post-processing accordingly. 😊

Let me know if you need further assistance!

[vonzo]

If I want to predict on several images at once I should use a tensor with the format BCHW format with RGB channels float32 (0.0-1.0). . Is there a way to use this with a group of images of different sizes and ratios?

[pderrenger]

@vonzo hey there! 👋

For predicting on a batch of images with different sizes and ratios using a tensor in BCHW format, you'll need to resize or pad the images to a common size before stacking them into a single tensor. YOLO models typically require a consistent input size for batch processing.

Here's a quick example of how you might prepare your images:

import torch
from PIL import Image
from torchvision.transforms import functional as F

# Load your images
images = [Image.open(path) for path in ['image1.jpg', 'image2.jpg', ...]]

# Resize or pad them to the same size
processed_images = [F.to_tensor(F.resize(img, (640, 640))) for img in images]

# Stack into a single tensor
batch_tensor = torch.stack(processed_images).to('cuda')  # if using GPU

# Predict with your model
model = YOLO('yolov8n.pt')
results = model(batch_tensor)

Remember to adjust the resize dimensions (640, 640) to match your model's input size. Happy coding! 😊

[vonzo]

If I want to predict on several images at once I should use a tensor with the format BCHW format with RGB channels float32 (0.0-1.0). . Is there a way to use this with a group of images of different sizes and ratios?

[glenn-jocher]

Hey there! 👋

For predicting on a batch of images with different sizes and ratios, you'll need to resize or pad them to a common size before creating the tensor. YOLO models typically require a consistent input size for batching.

Here's a quick example of how you might preprocess your images:

import torch
from PIL import Image
from ultralytics import YOLO

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

# List of your images
image_paths = ['image1.jpg', 'image2.jpg', 'image3.jpg']
images = [Image.open(x).convert('RGB') for x in image_paths]

# Resize or pad your images to a common size, e.g., (640, 640)
common_size = (640, 640)
preprocessed_images = [img.resize(common_size) for img in images]

# Convert to tensor
tensors = [torch.from_numpy(np.array(img)).permute(2, 0, 1) for img in preprocessed_images]
batch_tensor = torch.stack(tensors).float() / 255.0  # Normalize to [0, 1]

# Predict
results = model(batch_tensor)

Remember to adjust common_size to the input size your model expects. Happy coding! 😊

[FAhmedS]

This aint working:
import torch
from ultralytics import YOLO

Load a pretrained YOLOv8n model

model = YOLO('yolov8n.pt')

Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32

source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

Run inference on the source

results = model(source) # list of Results objects

ERROR:
FileNotFoundError: /content/tensor([[[[0.37700, 0.50762, 0.07964, ..., 0.21326, 0.03921, 0.76311],
[0.99283, 0.50216, 0.00139, ..., 0.28570, 0.19204, 0.36161],
[0.14086, 0.05902, 0.68003, ..., 0.21425, 0.37382, 0.68692],
...,
[0.96279, 0.66288, 0.08506, ..., 0.65062, 0.19491, 0.97699],
[0.08032, 0.12268, 0.20707, ..., 0.41444, 0.70152, 0.58322],
[0.65727, 0.67100, 0.54530, ..., 0.20908, 0.95698, 0.47706]],

     [[0.09262, 0.68764, 0.66347,  ..., 0.57848, 0.88790, 0.09426],
      [0.95230, 0.49461, 0.23566,  ..., 0.76413, 0.30803, 0.78175],
      [0.67073, 0.19519, 0.45866,  ..., 0.00747, 0.87357, 0.35077],
      ...,
      [0.42226, 0.47862, 0.12184,  ..., 0.45423, 0.67396, 0.27294],
      [0.39110, 0.78460, 0.54653,  ..., 0.93655, 0.26833, 0.18915],
      [0.95946, 0.67440, 0.44168,  ..., 0.45350, 0.63987, 0.39394]],

     [[0.15488, 0.41527, 0.24002,  ..., 0.21079, 0.87020, 0.95945],
      [0.01672, 0.11590, 0.23509,  ..., 0.27435, 0.74259, 0.50491],
      [0.76596, 0.01708, 0.54550,  ..., 0.95134, 0.51788, 0.23914],
      ...,
      [0.46882, 0.35401, 0.45893,  ..., 0.34754, 0.19933, 0.37761],
      [0.14124, 0.43750, 0.48391,  ..., 0.53138, 0.93484, 0.63695],
      [0.68540, 0.67760, 0.33487,  ..., 0.47994, 0.76724, 0.53667]]]]) does not exist

[pderrenger]

Hey there! 👋 It looks like you're encountering a FileNotFoundError when trying to run inference with a YOLOv8 model. This error typically occurs when the model file isn't found at the specified path.

Here's a quick check you can do:

1. Ensure that the model file yolov8n.pt is correctly downloaded and located in the directory from where you're running the script.
2. If you're using a Jupyter notebook (like Google Colab), make sure the file is uploaded there.

If the model file is in the right place and you're still facing issues, try providing the absolute path to the model file in the YOLO() function.

Here's an example:

model = YOLO('/absolute/path/to/yolov8n.pt')

Give this a shot and let us know if it helps! If the problem persists, we're here to assist further. 😊

[teengineer]

Hello, i export the model (yolov8-seg.onnx), and i use this model in react. how can i take the outline coordinates like 'masks.xy' in react app?

[glenn-jocher]

Hey there! 😊 To access the outline coordinates similar to masks.xy in your React app, you'll need to process the ONNX model output to extract the mask data. Here's a general idea of how you can do it:

1. Run your ONNX model in React and get the raw output.
2. Convert this output to a format that includes the mask coordinates.
3. Use these coordinates to render the outlines in your app.

For the conversion step, you might need to implement a function similar to the masks.xy attribute in the YOLOv8 Python code. If you're using a library like ONNX.js for inference, you'll process the output tensors to extract the mask data.

Here's a pseudo-code snippet to give you an idea:

// Assuming 'output' is the raw model output tensor that includes mask data
const masks = processMasks(output);

function processMasks(rawOutput) {
  // Your logic to extract and format mask coordinates goes here
  // This will depend on the structure of your model's output
}

// Use 'masks' in your React components to draw the outlines

Remember, the exact implementation will depend on the specifics of your model's output format. If you need more detailed guidance, the YOLOv8 documentation and community might have additional resources. Good luck with your project!

[teengineer]

Thank you for your response, i cant find masks.xy in the YOLOv8 Python code, may you help me for finding?

[pderrenger]

Hey there! 👋 It looks like you're trying to find the masks.xy attribute in the YOLOv8 Python code. This attribute is part of the Masks object, which you can access from the Results object after running inference with a segmentation model.

Here's a quick example of how you can get the masks.xy data:

from ultralytics import YOLO

# Load a pretrained segmentation model
model = YOLO('yolov8-seg.pt')

# Run inference on an image
results = model('path/to/image.jpg')

# Access the Masks object
masks = results[0].masks

# Get the xy coordinates of the masks
mask_coordinates = masks.xy

Make sure you're using a segmentation model like yolov8-seg.pt to get mask outputs. If you need further assistance, feel free to ask! 😊

[OmarKhaled0K]

I want to use YOLOv8 for multi-class image classification but yolov8n-cls have 1k classes which is way more than i want , i want to classify for just <80 class for example if image have Chihuahua and catfish model must return only dog and fish not the specific kind of dogs , how to do that ?
Thanks in advance

[glenn-jocher]

Hey there! 👋 For your multi-class image classification task with YOLOv8, you can customize the model to classify broader categories like 'dog' and 'fish' instead of specific breeds or types. Here's how you can approach it:

1. Prepare your dataset with the desired class labels (e.g., 'dog', 'fish').
2. Modify the dataset YAML file to reflect your new class names and their corresponding paths.
3. Train a new YOLOv8 model on your dataset. You can use a pretrained model as a starting point and fine-tune it on your data.

Here's a quick example of how to start training with your custom classes:

from ultralytics import YOLO

# Create a new YOLO model with your custom dataset
model = YOLO('path/to/your/custom_model.yaml')

# Train the model on your dataset
model.train(data='path/to/your/dataset.yaml', epochs=50)

Remember to adjust the epochs and other hyperparameters as needed. Good luck with your classification project, and if you have any more questions, feel free to ask! 😊

[full57]

How to get masks only conf is over 0.8? realtime capture by webcam

[pderrenger]

Hey there! 👋 To filter out masks with a confidence of over 0.8 during real-time webcam capture, you can check the conf attribute of the Results object after running the prediction. Here's a quick example using the YOLOv8 model:

from ultralytics import YOLO
import cv2

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

# Initialize webcam
cap = cv2.VideoCapture(0)

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

    # Run inference
    results = model(frame)

    # Filter masks by confidence > 0.8
    high_conf_masks = results.masks if results.masks.conf > 0.8 else None

    # Do something with the high confidence masks
    # ...

    # Show frame
    cv2.imshow('YOLOv8 Webcam', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

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

Make sure to adjust the model path to your specific model if needed. Happy coding! 😊

[foskyblue]

Hi guys, I have a situation and I'm wondering if anyone can help with it. I have a Yolov8 model exported to tflite using the command

model.export(format="tflite", imgsz=train_image_size)

I used two predict functions:

Predict function 1: Using the YOLO predict function from ultralytics

def yolov8_predict(
    image_path: str, model: str, image_size: str, annotations: str = ".."):

    from ultralytics import YOLO

    predict_image_size = tuple(image_size.split(","))
    predict_image_size = (int(predict_image_size[0]), int(predict_image_size[1]))

    tflite_model = YOLO(model, task="detect")
    predict_generator = tflite_model.predict(
        source=image_path, imgsz=predict_image_size, save=True, save_txt=True, save_conf=True, conf=0.05, stream=True
    )  # save predictions as labels
    pred = None
    for pred in predict_generator:
        pass

    if pred is None:
        print("No predictions was made...")
        sys.exit(1)

This function generates a txt file with the predictions, bounding boxes coordinates, and confidence scores.

Predict function 2: I used the tflite_runtime interpreter. With this method, I applied the pre-processing (using padding) as recommend by ultralytics. I then pass the pre-processed model to the tflite model (using the invoke function), and the post-processed the results using NMS and finally scale the boxes to fit the original image size.

def load_model(model_path):
   return tflite_model

def perform_prediction(pil_images: List[Image.Image], model_path):
    if interpreter is None:
        load_model(model_path)  # In case init() was not called or preload()->wait(futures) was delayed

    # Inference
    predictions = []
    # It is not possible to batch inference with this tflite model.
    for pil_image in pil_images:
        input_data = preprocess_image(pil_image, input_shape)
        interpreter.set_tensor(input_index, input_data)
        interpreter.invoke()
        output_data = interpreter.get_tensor(output_index)
        preds = postprocess_results(output_data, input_shape, (pil_image.size[1], pil_image.size[0]))
        predictions.append({
            'detection_classes': (preds[:, 5] + 1).tolist(),  # Class values are offset by +1.0
            'detection_boxes': preds[:, 0:4].tolist(),
            'detection_scores': preds[:, 4].tolist(),
        })
        del input_data, output_data  # Explicit deletion to ensure tensor is released
    return predictions


def xywh2xyxy(box: np.ndarray) -> np.ndarray:
    """
    Convert bounding box coordinates from (x, y, width, height) format to (x1, y1, x2, y2) format where (x1, y1) is the
    top-left corner and (x2, y2) is the bottom-right corner.

    Args:
        x (np.ndarray): The input bounding box coordinates in (x, y, width, height) format.

    Returns:
        np.ndarray: The bounding box coordinates in (x1, y1, x2, y2) format.
    """
    if box.shape[-1] != 4:
        raise ValueError(f"input shape last dimension expected 4 but input shape is {box.shape}")

    # pylint: disable=unbalanced-tuple-unpacking
    xy, wh = np.split(box, [2], axis=-1)
    wh_half = wh / 2
    return np.concatenate([xy - wh_half, xy + wh_half], axis=-1)


def box_iou_batch(boxes_a: np.ndarray, boxes_b: np.ndarray) -> np.ndarray:
    """
    Calculate the Intersection over Union (IoU) between two sets of bounding boxes.

    Args:
        boxes_a (np.ndarray): Array of shape (N, 4) representing N bounding boxes.
        boxes_b (np.ndarray): Array of shape (M, 4) representing M bounding boxes.

    Returns:
        np.ndarray: Array of shape (N, M) containing IoU values for each pair of boxes.

    Note:
        Each bounding box is represented as [x1, y1, x2, y2], where (x1, y1) is the
        top-left corner and (x2, y2) is the bottom-right corner.
    """
    # Calculate areas of boxes_a
    area_a = (boxes_a[:, 2] - boxes_a[:, 0]) * (boxes_a[:, 3] - boxes_a[:, 1])

    # Calculate areas of boxes_b
    area_b = (boxes_b[:, 2] - boxes_b[:, 0]) * (boxes_b[:, 3] - boxes_b[:, 1])

    # Calculate intersection coordinates
    top_left = np.maximum(boxes_a[:, None, :2], boxes_b[:, :2])
    bottom_right = np.minimum(boxes_a[:, None, 2:], boxes_b[:, 2:])

    # Calculate intersection area
    area_inter = np.prod(np.clip(bottom_right - top_left, a_min=0, a_max=None), 2)

    # Calculate IoU
    return area_inter / (area_a[:, None] + area_b - area_inter)


def numpy_nms(boxes: np.ndarray, scores: np.ndarray, iou_threshold: float = 0.7) -> np.ndarray:
    """
    Perform Non-Maximum Suppression (NMS) on a set of bounding boxes.

    Args:
        boxes (np.ndarray): Array of shape (N, 4) representing N bounding boxes.
                            Each box is [x1, y1, x2, y2].
        scores (np.ndarray): Array of shape (N,) representing the confidence scores
                             for each box.

        iou_threshold (float): IoU threshold for suppressing overlapping boxes.
                               Defaults to 0.7.

    Returns:
        np.ndarray: Boolean array of shape (N,) indicating which boxes to keep.
    """
    # Sort boxes by score in descending order
    order = scores.argsort()[::-1]
    keep = np.ones(len(boxes), dtype=bool)

    # Calculate IoU matrix
    ious = box_iou_batch(boxes, boxes)
    np.fill_diagonal(ious, 0)  # Set self-IoU to 0

    for i, idx in enumerate(order):
        if not keep[idx]:
            continue

        # Suppress boxes with IoU > threshold
        overlap = ious[idx] > iou_threshold
        keep[order[i + 1:]] &= ~overlap[order[i + 1:]]

    return keep


def non_max_suppression(
    prediction: np.ndarray,
    conf_thres: float = 0.25,
    iou_thres: float = 0.7,
    max_det: int = 300,
    max_wh: int = 7680,
):
    """
    Perform non-maximum suppression (NMS) on a single image prediction.

    Args:
        prediction (np.ndarray): A numpy array of shape (1, num_boxes, num_classes + 4 + num_masks)
            containing the predicted boxes, classes, and masks.
        conf_thres (float): Confidence threshold for filtering boxes (0.0 to 1.0).
        iou_thres (float): IoU threshold for NMS (0.0 to 1.0).
        max_det (int): Maximum number of boxes to keep after NMS.
        max_wh (int): Maximum box width and height in pixels.

    Returns:
        np.ndarray: Array containing kept boxes with format
        (x1, y1, x2, y2, confidence, class, mask1, mask2, ...).
    """

    # Input validation (can be removed if you're sure of your input)
    if 0 > conf_thres > 1:
        raise ValueError(f"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0")
    if 0 > iou_thres > 1:
        raise ValueError(f"Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0")

    # Extract dimensions and metadata directly
    _, _, dims = prediction.shape
    nc = dims - 4 - prediction.shape[1]  # number of classes
    nm = dims - nc - 4  # number of masks
    mi = 4 + nc  # mask start index

    # Process the single image in the batch
    x = prediction[0]  # Extract the single image data

    # Move class scores to last axis and threshold
    x = np.transpose(x, (1, 0))
    xc = x[..., 4:mi].max(axis=-1) > conf_thres
    x = x[xc]

    if not x.shape[0]:  # No boxes left after confidence thresholding
        return np.zeros((0, 6 + nm))

    # Convert xywh to xyxy directly on the filtered boxes
    x[..., :4] = xywh2xyxy(x[..., :4])

    # Split and process boxes, classes, and masks
    # pylint: disable=unbalanced-tuple-unpacking
    box, cls, mask = np.split(x, (4, mi), 1)
    conf = cls.max(1)
    j = cls.argmax(1)
    x = np.concatenate((box, conf[:, None], j[:, None].astype(float), mask), 1)
    x = x[conf > conf_thres]

    n = x.shape[0]
    if not n:  # No boxes left after additional confidence thresholding
        return np.zeros((0, 6 + nm))

    # NMS (simplified since we're dealing with a single image)
    c = x[:, 5:6] * max_wh
    boxes, scores = x[:, :4] + c, x[:, 4]
    i = numpy_nms(boxes, scores, iou_thres)
    i = i[:max_det]

    return x[i]


def letter_box(img: np.ndarray, new_shape: Tuple[int, int]) -> np.ndarray:
    """
    Resizes an image to fit within a new shape while maintaining the aspect ratio,
    and pads the remaining space with a constant value.

    Args:
        img (np.ndarray): The input image as a NumPy array.
        new_shape (Tuple[int, int]): The desired output shape (height, width).

    Returns:
        np.ndarray: The resized and padded image.
    """

    shape = img.shape[:2]

    # Calculate the scaling ratio to fit the image within the new shape
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])

    # Calculate the new unpadded dimensions
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))

    # Calculate the padding required on each side
    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
    dw, dh = dw / 2, dh / 2

    # Resize the image if necessary
    if shape[::-1] != new_unpad:
        img = Image.fromarray(img).resize(new_unpad, Image.Resampling.BILINEAR)
        img = np.array(img)

    # Calculate the top, bottom, left, and right padding values
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))

    # Add padding to the image
    img = np.pad(img, ((top, bottom), (left, right), (0, 0)), mode='constant', constant_values=114)

    return img


def preprocess_image(pil_image: Image.Image, input_size: Tuple[int, int]) -> np.ndarray:
    """
    Preprocesses an image for inference with a TFLite model.

    Args:
        image_path (str): Path to the image file.
        input_size (Tuple[int, int]): Desired input size (height, width) for the model.

    Returns:
        np.ndarray: Preprocessed image as a NumPy array, ready for inference.
    """
    if pil_image.mode != "RGB":
        pil_image = pil_image.convert("RGB")

    im = np.asarray(pil_image)
    im = letter_box(im, new_shape=input_size)
    im = np.expand_dims(im, axis=0)
    im = im.astype(np.float32) / 255.0  # Normalize to 0.0 - 1.0

    return im


def postprocess_results(output: np.ndarray, model_input_size: Tuple[int, int], image_original_size: Tuple[int, int]) -> np.ndarray:
    """
    Postprocesses the raw outputs from a TFLite model, including scaling bounding boxes back to the original image size.

    Args:
        output (np.ndarray): List of output tensors from the TFLite model.
        model_input_size (Tuple[int, int]): Desired input size (height, width) for the model.
        image_original_size (Tuple[int, int]): Original size (height, width) of the input image.

    Returns:
        np.ndarray: Postprocessed results with bounding boxes adjusted to original image size.
    """

    predictions = non_max_suppression(output, conf_thres=0.25, iou_thres=0.7, max_det=300, max_wh=1)
    return scale_boxes(image_original_size, predictions, model_input_size)


def scale_boxes(image_original_size: Tuple[int, int], boxes: np.ndarray, model_input_size: Tuple[int, int]):
    """
    Rescales bounding boxes (in the format of xyxy by default) from the shape of the image they were originally
    specified in (img1_shape) to the shape of a different image (img0_shape).

    Args:
        image_original_size (Tuple[int, int]): The shape of the image that the bounding boxes are for, in the format of (height, width).
        boxes (np.ndarray): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2)
        model_input_size (Tuple[int, int]): the shape of the target image, in the format of (height, width).

    Returns:
        np.ndarray: The scaled bounding boxes, in the format of (x1, y1, x2, y2)
    """

    # calculate from img0_shape
    gain = min(model_input_size[0] / image_original_size[0], model_input_size[1] / image_original_size[1])  # gain  = old / new
    pad = (
        round((model_input_size[1] - image_original_size[1] * gain) / 2 - 0.1) / model_input_size[1],
        round((model_input_size[0] - image_original_size[0] * gain) / 2 - 0.1) / model_input_size[0],
    )  # wh padding

    inner_image_scale = (
        (1 - pad[0] * 2),
        (1 - pad[1] * 2),
    )  # wh scale

    boxes[..., 0] = (boxes[..., 0] - pad[0]) / inner_image_scale[0]  # x padding
    boxes[..., 1] = (boxes[..., 1] - pad[1]) / inner_image_scale[1]  # y padding
    boxes[..., 2] = (boxes[..., 2] - pad[0]) / inner_image_scale[0]  # x padding
    boxes[..., 3] = (boxes[..., 3] - pad[1]) / inner_image_scale[1]  # y padding

    boxes[..., [0, 2]] = boxes[..., [0, 2]].clip(0, 1)  # x1, x2
    boxes[..., [1, 3]] = boxes[..., [1, 3]].clip(0, 1)  # y1, y2
    return boxes

I get very good bounding boxes with the correct classes for both predict functions. However, the predictions are not the same for all images. Sometimes predict function 1 gives more predictions than function 2 and vice-versa. My expectation is that the predictions from both predict function should be equal for any image since it's same tflite model.

Am I missing something?

[glenn-jocher]

@foskyblue it seems like the difference in predictions might be due to variations in preprocessing or postprocessing between the two methods. Ensure that both functions apply the same preprocessing steps, such as image resizing and normalization, and use identical postprocessing parameters like confidence and IoU thresholds. This consistency should help align the results.

[foskyblue]

Thanks for your response @glenn-jocher. How do I know what exact processing and post processing that are applied using the ultralytics predict function? i.e.

predict_generator = tflite_model.predict(
        source=image_path, imgsz=predict_image_size, save=True, save_txt=True, save_conf=True, conf=0.05, stream=True
    )  # save predictions as labels

[glenn-jocher]

@foskyblue to understand the exact processing and post-processing applied in the Ultralytics predict function, you can refer to the Ultralytics documentation. It details the preprocessing steps like resizing and normalization, and post-processing like Non-Maximum Suppression (NMS). This should help align your custom implementation with the built-in function.

[ApodiAlsurihi]

import torch
import cv2
import numpy as np
from time import time
from ultralytics import YOLO

class ObjectDetection :

def __init__(self,caputr_index):
    self.caputr_index=caputr_index
    self.device='cuda' if torch.cuda.is_available() else 'cpu'
    print('using device ',self.device)
    self.model=self.load_model()
    
    
    
def load_model (self) :
    model=YOLO(r'C:\Users\Owner\Desktop\python\yolo\weight\yolov10l.pt')
    model.fuse()
    return model  



def predict (self,frame):
    results=self.model(frame)
    return results




def plot_boxes (self,results,frame):
    xyxy=[]
    confidances=[]
    calss_ids=[]
    
    for result in results:
        boxes=result.boxes.cpu().numpy()
        print(boxes)
    
    return frame 



def __call__(self):
     
     cap=cv2.VideoCapture(self.caputr_index)
     assert cap.isOpened()

ObjectDetection(0)

I write all the code as shown in the video but nothin happened
just

ObjectDetection(0)

[glenn-jocher]

@ApodiAlsurihi it seems like there might be an issue with how the ObjectDetection class is being called. Ensure that the __call__ method is properly implemented to start the video capture loop. You might need to instantiate the class and call it like this: detector = ObjectDetection(0); detector(). If you need further assistance, please refer to the YOLO predict mode documentation.

[baqwas]

Raspberry Pi 5 Error Message
Error in cpuinfo: prctl(PR_SVE_GET_VL) failed

Computation completes successfully on Raspberry Pi 5 Model B Rev 1.0 running (RPi) Debian GNU/Linux 12 (bookworm) aarch64. IDE is PyCharm Community Edition 2024.2.3.

Code snippet is the first example in this article above. Message originates probably in the call to teh basic statement:
results = model(["my_image1.jpg", "my_image2.jpg"]) # return a list of Results objects

Not an issue (results entity is fully complete, of course!) but perhaps worthy of attention for a low-priority minor fix in a future upgrade. Thanks.

Regards.

[glenn-jocher]

@baqwas thank you for bringing this to our attention. The error message seems related to system-specific configurations rather than the YOLO code itself. We'll consider this for future updates. For now, if the results are complete, it should not affect your workflow.

[baqwas]

Agree fully. Thanks.

[glenn-jocher]

@baqwas thank you for your feedback. We'll consider this for future updates. If the results are complete, it should not impact your workflow. For further assistance, please refer to our documentation.

[baqwas]

results object drill-down question:
How to get access to the COCO labels (as used in YOLO models)?
boxes.cls has the indices to the COCO labels but not the label text strings which are annotated in "savefile" image as visible via result.save(). Perhaps I didn't look carefully into the class definitions for the results objects such boxes and masks? Is some attribute in masks? Thanks.

[glenn-jocher]

@baqwas to access COCO label text strings, use the names attribute in the Results object, which maps class indices to labels. This should help you retrieve the label names corresponding to the indices in boxes.cls.

[baqwas]

Thanks! Comprehension mistake on my part. Saw all the labels and didn't "think" that I should use that data with the available indices. Thanks again for helping out so quickly.

Regards.

[glenn-jocher]

You're welcome! If you have any more questions or need further assistance, feel free to ask.

[josiahkim29]

The plotting of results is much easier!!!

[glenn-jocher]

@josiahkim29 thank you for your feedback! If you have any questions or need further assistance with Ultralytics YOLO, feel free to ask. For more details on prediction and plotting, you can visit our documentation.

[AlgosDuCouteau]

hi, I am facing some issue with streaming for-loop code, I copy as your reference then only change the path of model and video source, but when I run it using python debugger, it shows
"0: 384x640 (no detections), 60.2ms
Speed: 6.5ms preprocess, 60.2ms inference, 38.5ms postprocess per image at shape (1, 3, 384, 640)"
and stop at this, nothing happened next. I also try with the reference code in YOLOV8-region-counter and get the same result when pass --view-img. My env is WSL-ubuntu22.04, python 3.10, both ultralytics and opencv-python are latest version.

[glenn-jocher]

@AlgosDuCouteau it seems like the issue might be related to the video source or model path. Ensure the paths are correct and accessible. Also, try running the script without the debugger to see if it behaves differently. If the problem persists, consider checking the video codec compatibility with OpenCV. For more details, you can refer to the Ultralytics documentation.

[cobaltautomationdev]

If I am mistaken, has anyone noticed any issues with the code example used for plotting? Specifically, it seems that im_bgr is assigned but not used afterward. If r.show() can directly display the image, why go through the extra steps of creating im_bgr and im_rgb?

https://docs.ultralytics.com/modes/predict/#plotting-results

[glenn-jocher]

The im_bgr and im_rgb variables are used to convert the image format for display or saving purposes, but if r.show() meets your needs, you can skip these steps. The conversion is useful if you need to manipulate the image further or save it in a specific format.

[ApodiAlsurihi]

The only thing that is been shown is yolo 10m summary (fused) :369 layers, 16,543,024 parameters,16,543,008 gradients,63.9 GFLOPs

…

On Sun, Oct 20, 2024, 4:54 AM Glenn Jocher ***@***.***> wrote: @ApodiAlsurihi <https://github.com/ApodiAlsurihi> it seems like there might be an issue with how the ObjectDetection class is being called. Ensure that the __call__ method is properly implemented to start the video capture loop. You might need to instantiate the class and call it like this: detector = ObjectDetection(0); detector(). If you need further assistance, please refer to the YOLO predict mode documentation <https://docs.ultralytics.com/modes/predict/>. — Reply to this email directly, view it on GitHub <#7932 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BCISNNXUHHI67OLZMFMSIVDZ4MEO5AVCNFSM6AAAAABCTDRDM6VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTAOJZGM4TQNA> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

@ApodiAlsurihi it seems like the issue might be related to the implementation of the ObjectDetection class. Please ensure that the __call__ method is correctly set up to initiate the video capture loop. For further guidance, you can refer to the YOLO predict mode documentation at https://docs.ultralytics.com/modes/predict/.

[Mrgorlay]

hello,@glenn-jocher,I have a question I'd like to ask. I want to use YOLO to perform inference on a 10-second video clip each time, and this 10-second video clip is constantly being polled and updated. In this case, I need to pass a list to the model, and this list should contain data for 10 seconds, which amounts to 250 frames, assuming a frame rate of 25 fps. After detection is complete, how can I display the detection results in a smooth 10-second video without any lag? Thank you.

for i in range(num_channels):
while len(frame_buffers[i]) > 0:
frame = frame_buffers[i].pop(0)

            current_timestamp = time.time()

            frame_queues[i].append(frame)

            
            if len(frame_queues[i]) >= 250:
                print(len(frame_queues[i]),)                    
                results = model(list(frame_queues[i]), conf=confidence_threshold, iou=0.7, device=0)[0]

                for result in results:
                    # # result.show()
                    annotated_frame = results.plot()

                    image_placeholders[i].image(annotated_frame, channels="BGR", use_column_width=True)

[glenn-jocher]

To achieve smooth video playback without lag, consider using stream=True for memory-efficient processing and ensure your display method can handle real-time updates. Adjust your frame processing to maintain a consistent frame rate.

[astronging]

Thank you so much for your help.

[glenn-jocher]

Thank you for your question. To display detection results smoothly in a 10-second video, consider using stream=True for efficient memory management and ensure your display method can handle real-time updates. Adjust your frame processing to maintain a consistent frame rate.

[astronging]

Please help me. I've now labeled 9 kinds of data sets myself. But I want to train some of these classes with multiple networks, but it lacks the prompt error. Please help me with this. Errors are as follows。
Traceback (most recent call last):
File "D:\Py_Projects\yolov107.15\ultralytics\engine\trainer.py", line 138, in init
self.data = check_det_dataset(self.args.data)
File "D:\Py_Projects\yolov107.15\ultralytics\data\utils.py", line 297, in check_det_dataset
data["names"] = check_class_names(data["names"])
File "D:\Py_Projects\yolov107.15\ultralytics\nn\autobackend.py", line 35, in check_class_names
raise KeyError(
KeyError: '2-class dataset requires class indices 0-1, but you have invalid class indices 3-4 defined in your dataset YAML.'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
File "D:\Py_Projects\yolov107.15\train.py", line 8, in
results = model.train(data="sfh.yaml", epochs=200, batch=8,workers=0)
File "D:\Py_Projects\yolov107.15\ultralytics\engine\model.py", line 638, in train
self.trainer = (trainer or self._smart_load("trainer"))(overrides=args, _callbacks=self.callbacks)
File "D:\Py_Projects\yolov107.15\ultralytics\engine\trainer.py", line 142, in init
raise RuntimeError(emojis(f"Dataset '{clean_url(self.args.data)}' error ❌ {e}")) from e
RuntimeError: Dataset 'sfh.yaml' error '2-class dataset requires class indices 0-1, but you have invalid class indices 3-4 defined in your dataset YAML.'

This is my yolov10n. yaml

Parameters

nc: 2 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'

[depth, width, max_channels]

n: [0.33, 0.25, 1024]

This is my path file
train: D:\Py_Projects\datasets\xiangmu\images\train # train images (relative to 'path') 128 images
val: D:\Py_Projects\datasets\xiangmu\images\val # val images (relative to 'path') 128 images
test: # test images (optional)

Classes

names:
3: bolt-normal
4: bolt-off

[glenn-jocher]

@astronging the error indicates that your dataset YAML file has class indices 3 and 4, but your model is configured for 2 classes (indices 0 and 1). Please update your dataset YAML to use class indices 0 and 1, or adjust the nc parameter in your model configuration to match the number of classes in your dataset.

[astronging]

Thank you so much for your help.

[glenn-jocher]

Thank you for your appreciation. If you have any further questions or need assistance, feel free to ask here.

[tylerfrisinger01]

I know that you can do "max_det" to specify the max amount of detections in a frame of a video, is it possible to set a max_detect for each class within a frame? For example it sometimes labels the same object with both class names, If i am able to set a max limit of 1 for each class this would not be a problem. Thank you! please get back to me!

[glenn-jocher]

@tylerfrisinger01 to achieve a per-class detection limit, you can implement custom post-processing on the Results object to filter detections by class after inference. This approach allows you to manually limit the number of detections per class within each frame.

[tylerfrisinger01]

@glenn-jocher my apologies I’m pretty new to using YOLO, do you have a sample of code of this being done? Or is there anything similar to this on the docs?

[glenn-jocher]

To filter detections by class, you can iterate over the Results object and apply custom logic to limit detections per class. Here's a minimal example:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")

# Run inference
results = model("image.jpg")

# Post-process results to limit detections per class
max_detections_per_class = 1
filtered_results = []
for result in results:
    class_counts = {}
    for box in result.boxes:
        cls = int(box.cls)
        if class_counts.get(cls, 0) < max_detections_per_class:
            filtered_results.append(box)
            class_counts[cls] = class_counts.get(cls, 0) + 1

# Use filtered_results as needed

This code snippet demonstrates how to limit the number of detections per class. Adjust max_detections_per_class as needed.

[tylerfrisinger01]

@glenn-jocher I am trying to apply this to the following code. I adjusting the code that I have pasted below so that it then displays the filtered_results instead of results, I.E. "annotated_frames = filtered_results[0].plot "so that the video correctly only shows one object per class however I can not because the "Boxes" object has no attribute 'plot'. What would your recommendation be for a workaround? I saw that I could possibly draw and label my own boxes based on the box coordinates however this seems very messy and if there is a easier way to do it that would be preferred.

cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = detection.predict(frame, conf=0.20, save_crop=True) #adjust confidence once model is trained better
        

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.namedWindow('custom window', cv2.WINDOW_KEEPRATIO) #change this so it doesnt open a video and it just saves to folder
        cv2.resizeWindow("custom window", 600, 600)
        cv2.imshow("custom window", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

[glenn-jocher]

To work around the limitation of not having a plot method for the Boxes object, you can use the coordinates from filtered_results to draw boxes manually using OpenCV functions like cv2.rectangle. While it might seem a bit cumbersome, it's a common approach when customizing display logic. Alternatively, reconsider the full Results object and filter visually by setting transparency or other visual cues for boxes you want to exclude.

[baqwas]

Nice! This is very helpful because I too needed this snippet. Thanks!

[glenn-jocher]

@baqwas i'm glad you found the snippet helpful! If you have any more questions or need further assistance, feel free to ask.

[tylerfrisinger01]

I just want to clarify as my team and myself are trying to fine tune our model, but is this the correct process? As long as detection is a path to our previously trained model and the results with the "data.yml" is the path to our newly annotated images in the spots that is having a hard time in? Just want to clarify so we can make sure to do it correctly.

detection = YOLO("runs/detect/train/weights/best.pt")

results = detection.train(data="data.yaml", epochs=300, imgsz=640)

[glenn-jocher]

@tylerfrisinger01 yes, that process is correct for fine-tuning your model. Just ensure that the "data.yaml" file correctly points to your newly annotated images, and you're set to continue training with your specified parameters. For more details, you might find our training guide helpful. If you have any other questions, feel free to ask!

[tylerfrisinger01]

@glenn-jocher on your discord channel a mod told me that I am better off not doing this since all that does is overwrite my previous weights and I am better of just starting over again and retraining it like i did the first time but with these new images added as well. Is this not true? He also told me that I should not use the model.tune() function because that will not really ever help me.

[glenn-jocher]

If you're retraining with new data, starting from your existing weights can be beneficial, as it incorporates prior learning. However, if the new data significantly differs or if you're addressing specific issues, integrating it into a larger, more diverse dataset might provide better results. The model.tune() function isn't typically a primary tool for significant model refinement but can be useful for minor adjustments. For more guidance, check the Ultralytics training documentation.

[seungdae251]

Hi.
I've tried
yolo detect predict model=./runs/detect/train14/weights/best.pt source=/data/tractor imgsz=640 rect=False

but the image size won't change into sqaure(640x640) but still works on rectangle(384x640).
Is there any way to run the inference on square(640x640)?

Thanks

[glenn-jocher]

@seungdae251 to ensure your input images are resized to a square dimension (e.g., 640x640) during inference, set the rect argument to True in your command. YOLO's rect=False allows non-square resizing to maintain aspect ratios. Switching to rect=True will force square padding. Let me know if you need further guidance!

[hefangnan]

My understanding is that the IOU here refers to the value of filtering overlapping boxes when NMS. If I want to adjust the IOU value between the predicted box and the gtBox, how can I set it?

[glenn-jocher]

@hefangnan to adjust the IOU threshold during Non-Maximum Suppression (NMS), modify the iou parameter in the model.predict() method. For example:

model.predict("image.jpg", iou=0.5)

This sets the IoU threshold to 0.5 for filtering overlapping boxes. You can use any value between 0 and 1 to control the overlap threshold. More details on this parameter can be found in the predict mode documentation.