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

[tianlongyang-bot]

self.model = YOLO("model/2.27best.engine",task="detect")
results = self.model.predict(self.source, stream=True, device=0, vid_stride=10)

result ：
Loading D:\myUI\model\2.27best.engine for TensorRT inference...
[05/15/2024-09:16:45] [TRT] [I] Loaded engine size: 19 MiB
[05/15/2024-09:16:45] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in engine deserialization: CPU +0, GPU +17, now: CPU 0, GPU 17 (MiB)
[05/15/2024-09:16:45] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in IExecutionContext creation: CPU +0, GPU +19, now: CPU 0, GPU 36 (MiB)
[05/15/2024-09:16:45] [TRT] [W] CUDA lazy loading is not enabled. Enabling it can significantly reduce device memory usage and speed up TensorRT initialization. See "Lazy Loading" section of CUDA documentation https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#lazy-loading

1/3: rtsp://admin:@xx192.168.1.107:554/cam/realmonitor?channel=1&subtype=0... Success ✅ (inf frames of shape 1920x1080 at 25.00 FPS)
2/3: rtsp://admin:@xx192.168.1.108:554/cam/realmonitor?channel=1&subtype=0... Success ✅ (inf frames of shape 2560x1440 at 25.00 FPS)
3/3: rtsp://admin:xx@192.168.1.64:554/Streaming/Channels/1... Success ✅ (inf frames of shape 1920x1080 at 25.00 FPS)

The printing of the console has no further information, and the program is still running and cannot be detected

[piaoyaoi]

I am using the stream=True parameter, if I set vid stride=30, in this loop for r in results: he will wait for vid stride interval, but I do not want to wait, in the interval does not detect, return to the original frame, what should I do

[pderrenger]

It sounds like you want to process every frame immediately in your loop with stream=True without waiting for the vid_stride interval when no detections occur. If you want to process every frame but only show them during the detection intervals determined by vid_stride=30, you might consider checking if any objects were detected and if not, just display the original frame.

Here's a snippet of how you could modify your loop:

from ultralytics import YOLO

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

# Assume 'cap' is your cv2.VideoCapture object
while cap.isOpened():
    success, frame = cap.read()
    if success:
        # Predict and skip frames according to vid_stride
        results = model(frame, stream=True, vid_stride=30)
        
        # Check if any objects were detected
        if results:
            for result in results:
                # Process and display results
                annotated_frame = result.plot()
                cv2.imshow("Results", annotated_frame)
        else:
            # If no results, display the original frame
            cv2.imshow("Results", frame)

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

Here, the model processes every frame but shows results only on frames where detections occur based on the specified vid_stride. If no detections are found in the interim, it simply displays the original frames. This way, there's no waiting and the original stream continuity is maintained.

[piaoyaoi]

I used this code, and it loops through while cap.isOpened(): instead of the iterator for result in results:, so it's still monitoring every frame

[pderrenger]

@piaoyaoi it sounds like you're using the stream=True with vid_stride=30 to process every video frame but would like a way to handle frames during intervals without detections more effectively.

When you set stream=True and specify a vid_stride other than 1, it will indeed skip processing for the defined stride interval and not perform any operation on interim frames, resulting in no outputs during these intervals. If you don't want to wait and wish to process or display every frame, here's a suggested approach:

You can manually handle the video frame processing within the loop by checking if there are any detections and then choose to display or process the original frame during no-detection intervals.

Here's a modified code snippet to illustrate:

import cv2
from ultralytics import YOLO

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

# Video capture
cap = cv2.VideoCapture('path/to/video.mp4')

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

    # Run detection every 30 frames
    if int(cap.get(cv2.CAP_PROP_POS_FRAMES)) % 30 == 0:
        results = model(frame, stream=True)
        if results:
            # Process detection results
            for result in results:
                annotated_frame = result.plot()
                cv2.imshow('YOLOv8 Inference', annotated_frame)
        else:
            # Show the original frame if no results
            cv2.imshow('YOLOv8 Inference', frame)
    else:
        # Show the original frame during non-check intervals
        cv2.imshow('YOLOv8 Inference', frame)

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

cap.release()
cv2.destroyAllWindows()

In this script, the model runs inference on every 30th frame. For all other frames, or when the detection returns no results, the original video frame is displayed. This way, you can maintain the real-time display of the video and process detections at desired intervals without delays.

[piaoyaoi]

Thank you. One solution in this lifetime

[pderrenger]

Hello! If you're using stream=True with vid_stride=30 and want to handle frames during non-detection intervals more effectively, you might consider manually controlling the frame processing within your loop. Here’s a simple way to do it:

import cv2
from ultralytics import YOLO

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

# Open the video file
cap = cv2.VideoCapture('path/to/your/video.mp4')
frame_count = 0

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

    # Process every frame, but only run detection every 30 frames
    if frame_count % 30 == 0:
        results = model(frame, stream=True)
        for result in results:
            annotated_frame = result.plot()
            cv2.imshow('YOLOv8 Inference', annotated_frame)
    else:
        cv2.imshow('YOLOv8 Inference', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    frame_count += 1

cap.release()
cv2.destroyAllWindows()

This script processes every frame for display but only runs detections every 30 frames. It should help maintain a real-time display without waiting for the vid_stride intervals. Hope this helps! 😊

[codin-son]

hi all, i want to ask, why when i run this code

from ultralytics import YOLO
import cv2

def check_stream(url):
cap = cv2.VideoCapture(url)
ret, frame = cap.read()
cap.release()
return ret

Example usage

Load a pretrained YOLOv8n model

model = YOLO('yolov8n.pt')

steam_url = "rtsp://192.168.1.18:554/1/h264major"

Run inference on the source

results = model(steam_url, stream=True, show=True, stream_buffer=True) # generator of Results objects

it doesnt show the video stream and will end the process immediately

[pderrenger]

Hello! It sounds like the video stream isn't behaving as expected. A common cause of this issue when streaming video feeds in real-time applications is the need to keep the video capture object (cap) open and to continuously poll for new frames inside a loop.

Here is a revised approach that continuously reads frames from the video stream and processes them using the YOLO model:

from ultralytics import YOLO
import cv2

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

# Define the RTSP stream URL
stream_url = "rtsp://192.168.1.18:554/1/h264major"

# Open the video stream
cap = cv2.VideoCapture(stream_url)

# Check if the video stream was opened successfully
if not cap.isOpened():
    print("Error: Could not open video stream")
else:
    while True:
        ret, frame = cap.read()  # Read the next frame from the stream
        if not ret:
            print("Error: Can't receive frame (stream end?). Exiting...")
            break

        # Run YOLO prediction on the current frame
        results = model(frame)

        # Visualize the results on the current frame
        results.show()

        # Press 'q' to break out of the loop
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

# Release the video capture and close windows
cap.release()
cv2.destroyAllWindows()

Please ensure that the RTSP stream URL is correct and that the stream is actively running. If the problem persists, it could be related to network issues or configurations specific to the stream or camera.

[LordofDucks00]

Hi! I am trying to make my pi camera to tcp stream the detection. How do I make the cap = cv2.VideoCapture(0) work with the results = model('tcp://127.0.0.1:8888'). Because the TCP stream is working but I can't open a window to see what it's detecting.

Here is my code:

import cv2
import pandas as pd
import numpy as np
from ultralytics import YOLO
from tracker import*
import time
from math import dist
model = YOLO('yolov8n.pt')
model.export(format='ncnn')
ncnn_model = YOLO('yolov8n_ncnn_model')
results = model('tcp://127.0.0.1:8888')

def RGB(event, x, y, flags, param):
if event == cv2.EVENT_MOUSEMOVE :
colorsBGR = [x, y]
print(colorsBGR)

cap = cv2.VideoCapture(0)
cv2.namedWindow('RGB')
cv2.setMouseCallback('RGB', RGB)
cv2.namedWindow('RGB')

my_file = open("coco.txt", "r")
data = my_file.read()
class_list = data.split("\n")

count=0

tracker=Tracker()

cy1=250
cy2=350

offset=6

vh_down={}
counter=[]

while True:
ret,frame = cap.read()
if not ret:
break
count += 1
if count % 3 != 0:
continue
frame=cv2.resize(frame,(480,480))

results=model.predict(frame)

a=results[0].boxes.data
px=pd.DataFrame(a).astype("float")

list=[]
         
for index,row in px.iterrows():

    x1=int(row[0])
    y1=int(row[1])
    x2=int(row[2])
    y2=int(row[3])
    d=int(row[5])
    c=class_list[d]
    if 'car' in c:
        list.append([x1,y1,x2,y2])
bbox_id=tracker.update(list)
for bbox in bbox_id:
    x3,y3,x4,y4,id=bbox
    cx=int(x3+x4)//2
    cy=int(y3+y4)//2
    cv2.rectangle(frame,(x3,y3),(x4,y4),(0,0,255),2)
    
    if cy1<(cy+offset) and cy1 > (cy-offset):
       vh_down[id]=time.time()
    if id in vh_down:
      
       if cy2<(cy+offset) and cy2 > (cy-offset):
         elapsed_time=time.time() - vh_down[id]
         if counter.count(id)==0:
            counter.append(id)
            distance = 10 
            a_speed_ms = distance / elapsed_time
            a_speed_kh = a_speed_ms * 3.6
            cv2.circle(frame,(cx,cy),4,(0,0,255),-1)
            cv2.putText(frame,str(id),(x3,y3),cv2.FONT_HERSHEY_COMPLEX,0.6,(255,255,255),1)
            cv2.putText(frame,str(int(a_speed_kh))+'Km/h',(x4,y4 ),cv2.FONT_HERSHEY_COMPLEX,0.8,(0,255,255),2)

       

cv2.line(frame,(0,cy1),(480,cy1),(255,255,255),1)
cv2.putText(frame,('L1'),(0,250),cv2.FONT_HERSHEY_COMPLEX,0.8,(0,255,255),2)
cv2.line(frame,(0,cy2),(480,cy2),(255,255,255),1)
cv2.putText(frame,('L2'),(0,350),cv2.FONT_HERSHEY_COMPLEX,0.8,(0,255,255),2)
d=(len(counter))
cv2.putText(frame,('goingdown:-')+str(d),(0,90),cv2.FONT_HERSHEY_COMPLEX,0.8,(0,255,255),2)
cv2.imshow("RGB", frame)
if cv2.waitKey(1)&0xFF==27:
    break

cap.release()
cv2.destroyAllWindows()

[pderrenger]

@LordofDucks00 hi! It looks like you're on the right track by using your TCP stream as the input source for your YOLO model. For visualizing the detections directly from the stream, you can use cv2.VideoCapture() with the stream URL instead of '0' which is typically used for webcam input. Here is a quick adjustment to your code:

Replace:

cap = cv2.VideoCapture(0)

With:

cap = cv2.VideoCapture('tcp://127.0.0.1:8888')

This change will direct OpenCV to capture video from your TCP stream. After updating cv2.VideoCapture(), your existing code for processing and displaying the video should work as expected.

Additionally, ensure any firewall or network settings are configured to allow TCP connections on the specified port if the stream does not connect. Keep up the great work with your project! 🚀

[LordofDucks00]

It worked! Thank you for your help.

[pderrenger]

I'm glad to hear it worked out for you! 🎉 If you have any more questions or need further assistance as you continue working with the YOLOv8 model, feel free to ask. Happy detecting!

[senthurram03]

I have a doubt regarding the YOLO OBB models. Are the result.obb.xyxyxyxy array of values considered as rotated rectangles or a polygon with four points??

[pderrenger]

Hello! Regarding your question about the result.obb.xyxyxyxy values in YOLO OBB models, these values represent the coordinates of a polygon with four points, defining a rotated rectangle. Each consecutive pair in the array represents a vertex of the polygon (rotated rectangle), starting from the top-left and moving clockwise around the rectangle.

If you need to visualize or further manipulate these values, you can treat them as coordinates of a four-point polygon that outlines the detected object. Here's a quick example of how you might access these values:

from ultralytics import YOLO

# Load a pretrained YOLOv8 OBB model
model = YOLO('yolov8n-obb.pt')

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

# Access the oriented bounding box (OBB) coordinates
for result in results:
    obb_coords = result.obb.xyxyxyxy
    print("OBB Coordinates:", obb_coords)

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

[senthurram03]

@pderrenger thanks for the reply, that doubt is because of how should we do the annotation.
Can we have annotations of any four points or it should strictly be a rotated rectangle??

[pderrenger]

Hi there! For the YOLO OBB models, the annotations should indeed represent a rotated rectangle, not just any four points. This means the points should be ordered and correspond to the corners of a rectangle that might be rotated with respect to the image axes. This structure is crucial for the model to correctly interpret the orientation and dimensions of the objects. If you have any more questions or need further clarification, feel free to ask. Happy annotating! 😊

[Asshok1]

Hey @glenn-jocher , I have a question related to threading on GPU, when I run this code on command prompt the cursor output is blinking without giving any output, without any error also on nvidia rtx a5000 24gb ram, when I run with 2 threads it is giving the output. Suppose if I'm increasing the threads like this I'm not getting the console output what is the reason for this and how to overcome this issue? Is this the problem with code or GPU or ultralytics ?

import torch
import threading
from ultralytics import YOLO
import os
import time

def model_load():
global model1, model2,model3
try:
device = 'cuda' if torch.cuda.is_available() else 'cpu'

     model1 = YOLO(r'best.pt').to(device)
     model2 = YOLO(r'best1.pt').to(device)
     model3 = YOLO(r'best2.pt').to(device)
     print("Models are loaded, ack_event is set.",flush = True)

except Exception as e:
    print('Error during model loading :',e)

model_load()

def fun1():
while True:
print('i am in funciton 1',flush=True)
results = model1(r"img.jpg")

def fun2():
while True:
print('i am in funciton 2',flush=True)
results = model1(r"img1.jpg")

def fun3():
while True:
print('i am in funciton 3',flush=True)
results = model1(r"img2.jpg")

if name=="main":

print('models are loaded',flush = True)

t1=threading.Thread(target=fun1)
t2=threading.Thread(target=fun2)
t3=threading.Thread(target=fun3)
t1.start()
t2.start()
t3.start()

[glenn-jocher]

@Asshok1 hey there! It sounds like you're encountering a threading issue with GPU utilization. When using multiple threads, each thread should ideally have its own model instance to avoid conflicts, especially when using GPU resources. Here’s a quick suggestion:

Ensure each thread uses a separate model instance and specify the device explicitly if not done already. Here's a modified version of your model_load() function to load different models for each thread:

def model_load():
    global model1, model2, model3
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    try:
        model1 = YOLO('best.pt').to(device)
        model2 = YOLO('best1.pt').to(device)
        model3 = YOLO('best2.pt').to(device)
        print("Models are loaded on", device)
    except Exception as e:
        print('Error during model loading:', e)

Also, ensure that each function in your threads calls a different model instance:

def fun1():
    while True:
        print('Function 1 is running', flush=True)
        results = model1('img.jpg')

def fun2():
    while True:
        print('Function 2 is running', flush=True)
        results = model2('img1.jpg')

def fun3():
    while True:
        print('Function 3 is running', flush=True)
        results = model3('img2.jpg')

This setup should help in managing GPU resources more effectively across threads. If the issue persists, consider checking for any GPU memory leaks or managing the CUDA context more explicitly. 🚀

[tianlongyang-bot]

If I want to run YOLO detection algorithms for different tasks in a program, should I use multithreading or multiprocessing? As far as I know, multiprocessing is good at handling CPU intensive computing, but the tutorial provided in the article is about multithreading. How should I choose?

[tianlongyang-bot]

In multi stream video detection, there is usually a demand for increasing or decreasing video streams. Is there a good way to change the prediction edge for YOLOv8 prediction in this situation? Is there a better way to detect the need to interrupt and then load new data and restart?

[arjunchandra2]

Hello, I have 2 questions.

1. I have trained a model where the dataset consists of 300x300 images which are resized to 640x640 images for training. I am now trying to use the model for predictions and I am wondering if the images should still be resized to 640x640 for predictions or if the accuracy will not be affected by leaving the images at 300x300?

2. Can rectangular images be used with model.predict()? In general, can any image dimension be used for model predictions? How does this work even though the network is fixed size - padding or rescaling or something else?

[pderrenger]

@arjunchandra2 hi there!

1. For predictions, it's best to resize your images to 640x640 to match the training conditions. This ensures consistency and maintains accuracy.

2. Yes, you can use rectangular images with model.predict(). YOLOv8 handles different dimensions by padding or resizing the images to fit the network's fixed size.

Feel free to experiment and see what works best for your specific use case! 😊

For more details, check out the Ultralytics YOLO predict mode documentation.

[DrukSonam]

Hello, how can I get the mask coordinates for each detected object? I want to make the detected object the ROI and with the help of mask coordinates I want to make other part as black and leave only ROI for further work. This is the code I wrote

import cv2
from pathlib import Path
from ultralytics.utils.plotting import save_one_box #it crops the detected image and saves in the folder
from random import randint
import numpy as np

results = model(img_path, imgsz=640, conf=0.25, iou=0.9, retina_masks=True) # return a list of Results objects
for result in results:
boxes = result.boxes # Boxes object for bounding box outputs
masks = result.masks

orig_img = cv2.imread(img_path)

for mask, box in zip(masks.xyn, boxes.xyxy):
crop_img=save_one_box(
box,
orig_img.copy(),
BGR=True,
save=False
)
polygon_coords=mask

    image_height,image_width = crop_img.shape[:2]
    polygon_coords[:, 0] *= image_width
    polygon_coords[:, 1] *= image_height

    # Convert float coordinates to integer values
    polygon_coords_int = np.round(polygon_coords).astype(int)        

    # Draw the polygon on the image
    new_img=cv2.polylines(crop_img,[polygon_coords_int],isClosed=True, color=(0,255,0), thickness=4, lineType=16)
    
    crop_img=cv2.resize(crop_img,(0,0), fx=0.5, fy=0.5)

    cv2.imshow(f'Image{i}', crop_img)
    cv2.waitKey(0)  # Wait for a key press to close the window
    cv2.destroyAllWindows()  # Close the window
    break #first trying with only detected one cropped image

I got this result....please help

[DrukSonam]

The mask coordinates i got was too small. I want it to be same size as crop image

[glenn-jocher]

Hi there! It looks like the mask coordinates you obtained are normalized, which is why they appear too small when applied to the cropped image. To fix this, you need to scale the mask coordinates to match the dimensions of the cropped image.

Here's a revised version of your code that should help:

import cv2
from pathlib import Path
from ultralytics.utils.plotting import save_one_box
from random import randint
import numpy as np
from ultralytics import YOLO

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

# Run inference
results = model(img_path, imgsz=640, conf=0.25, iou=0.9, retina_masks=True)

# Read the original image
orig_img = cv2.imread(img_path)

for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs

    for mask, box in zip(masks.xy, boxes.xyxy):
        # Crop the image using the bounding box
        crop_img = save_one_box(
            box,
            orig_img.copy(),
            BGR=True,
            save=False
        )

        # Scale the mask coordinates to the cropped image size
        polygon_coords = mask
        image_height, image_width = crop_img.shape[:2]
        polygon_coords[:, 0] *= image_width
        polygon_coords[:, 1] *= image_height

        # Convert float coordinates to integer values
        polygon_coords_int = np.round(polygon_coords).astype(int)

        # Create a black mask and draw the polygon on it
        mask_img = np.zeros_like(crop_img)
        cv2.fillPoly(mask_img, [polygon_coords_int], (255, 255, 255))

        # Apply the mask to the cropped image
        roi_img = cv2.bitwise_and(crop_img, mask_img)

        # Display the result
        roi_img = cv2.resize(roi_img, (0, 0), fx=0.5, fy=0.5)
        cv2.imshow('ROI Image', roi_img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
        break  # First trying with only detected one cropped image

This code scales the mask coordinates to the size of the cropped image and then applies the mask to keep only the region of interest (ROI). Let me know if you need further assistance! 😊

[DrukSonam]

Hello, I got all the black image. There is still a problem with the coordinates. when I print the mask for one object detection, I got this - print(polygon_coords_int)

[[278656 248460]
[278034 248864]
[276790 248864]
...
[282388 248864]
[280522 248864]
[279900 248460]]
and the crop image shape was (404, 622, 3)

I am expecting the results to be like this

[glenn-jocher]

@DrukSonam hello! It looks like the mask coordinates are not being scaled correctly. The coordinates you printed are much larger than the dimensions of your cropped image. This suggests that the coordinates are not normalized as expected.

To fix this, ensure that the mask coordinates are normalized before scaling them to the cropped image size. Here's an updated version of your code:

import cv2
from pathlib import Path
from ultralytics.utils.plotting import save_one_box
from random import randint
import numpy as np
from ultralytics import YOLO

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

# Run inference
results = model(img_path, imgsz=640, conf=0.25, iou=0.9, retina_masks=True)

# Read the original image
orig_img = cv2.imread(img_path)

for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs

    for mask, box in zip(masks.xyn, boxes.xyxy):
        # Crop the image using the bounding box
        crop_img = save_one_box(
            box,
            orig_img.copy(),
            BGR=True,
            save=False
        )

        # Scale the mask coordinates to the cropped image size
        polygon_coords = mask
        image_height, image_width = crop_img.shape[:2]
        polygon_coords[:, 0] *= image_width
        polygon_coords[:, 1] *= image_height

        # Convert float coordinates to integer values
        polygon_coords_int = np.round(polygon_coords).astype(int)

        # Create a black mask and draw the polygon on it
        mask_img = np.zeros_like(crop_img)
        cv2.fillPoly(mask_img, [polygon_coords_int], (255, 255, 255))

        # Apply the mask to the cropped image
        roi_img = cv2.bitwise_and(crop_img, mask_img)

        # Display the result
        roi_img = cv2.resize(roi_img, (0, 0), fx=0.5, fy=0.5)
        cv2.imshow('ROI Image', roi_img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
        break  # First trying with only detected one cropped image

This should correctly scale the mask coordinates to match the dimensions of the cropped image. Let me know if this helps! 😊

[arjunchandra2]

For predictions, I am getting the following Boxes object when I run a model on an image:

xywh: tensor([[147.6703, 103.3262,  58.7257,  47.1307]])
xywhn: tensor([[0.5274, 0.4572, 0.2097, 0.2085]])
xyxy: tensor([[118.3075,  79.7609, 177.0331, 126.8916]])

Can the difference between xywh and xyxy format be clarified? In particular, following the Keras convention (https://keras.io/api/keras_cv/bounding_box/formats/) I thought that xywh format would be the (x,y) coordinates of the top left point of the bounding box along with the width and height. And then the xyxy format would be the (x,y) coordinates of the top left point of the bounding box and the bottom right point of the bounding box. But it seems like the xywh format is actually giving the (x,y) coordinates of the center of the bounding box? Could this be confirmed and perhaps clarified in the docs since this seems to be unlike other library conventions (eg. keras)

[glenn-jocher]

Hi there!

Great question! You are correct in your understanding. In the Boxes object, the xywh format indeed represents the center coordinates (x, y) of the bounding box along with its width and height. On the other hand, the xyxy format provides the coordinates of the top-left (x1, y1) and bottom-right (x2, y2) corners of the bounding box.

This difference is crucial for various applications and might differ from other libraries like Keras, which typically use the top-left corner for xywh. We appreciate your feedback and will consider clarifying this in our documentation to avoid any confusion.

Feel free to explore more about the Boxes class and its methods in our documentation.

Happy coding! 🚀

[yunhachoi]

Hello, I'm working on YOLOv8 and have some questions.

When I use the predict mode, I can obtain inference time of each images. However, the deviation of the inference times is too large. And if I run YOLO on native, the deviation is small, but it gets bigger on a container or VM. I know there are many variables that can affect performance, but I've controlled most of them to ensure the experimental environment is consistent.
Is there any reason for this, such as block I/O performance? What's the root cause of the inference performance?
Additionally, I'm curious why YOLO provides different inference times for the same picture every time.

Thanks for your help.

[glenn-jocher]

@yunhachoi hello,

Thank you for reaching out with your questions regarding inference time variability in YOLOv8's predict mode.

The deviation in inference times you're observing, especially when running in containers or VMs compared to native environments, can indeed be influenced by several factors. One common cause could be the I/O performance, particularly if the model or data is being read from a disk or network location that has variable response times. Additionally, virtualized environments often share resources between multiple processes, which can lead to less predictable performance.

Another factor could be thermal throttling on the hardware running the container or VM, which can vary more than on dedicated hardware, especially under continuous load.

As for the varying inference times for the same image, this can be due to several reasons:

• CPU/GPU Load: Other processes running on the machine can affect inference time.
• Thermal Throttling: Overheating can cause the CPU/GPU to slow down.
• Power Management: Changes in power state can affect performance.
• Caching Effects: The first run of inference might take longer as data is loaded into faster caches.

To minimize these effects, ensure that your testing environment is as controlled as possible, with minimal background processes, and monitor the thermal and power states of your hardware.

For further details on optimizing performance and understanding the predict mode, you might find the Predict Mode Documentation helpful.

Let us know if you have more questions or need further assistance!

[junhyukkkkk]

Hello,
When running yolov8 on Ubuntu 18.04, only one of the four CPU cores is used.
In higher versions of Ubuntu, all 4 cores were used when running yolov8.
How do I make Ubuntu 18.04 use all 4 cores?
Thank you :)

[glenn-jocher]

@junhyukkkkk hello,

Thanks for reaching out! It seems like the issue with CPU core utilization might be related to the Python environment or specific system settings on Ubuntu 18.04. Here are a couple of suggestions you can try:

1. Set the Number of Threads: You can explicitly set the number of threads Python uses by setting the environment variable before running your script. You can do this in your terminal:

   export OMP_NUM_THREADS=4
   python your_script.py

2. Upgrade Python: Sometimes, upgrading Python to a newer version can help optimize resource usage. Python 3.7+ has better internal management for multiprocessing.

3. Check System Settings: Ensure that there are no system restrictions in place that limit the number of CPU cores for applications. You can check this in your system settings or system manager.

If these steps don't resolve the issue, it might be helpful to look into more specific configurations or updates for Ubuntu 18.04 that could be affecting core utilization.

[tianlongyang-bot]

Hello, I would like to add a detection interval to the prediction input data, requiring only the results within the detection interval to be obtained, without considering those outside the interval. May I ask if this algorithm integrates this feature into the prediction? Or do you need to write it yourself?

[tianlongyang-bot]

Does the algorithm integrate the function of drawing a rectangular box for detecting images, predicting only the image content within the rectangular box, or returning only the image prediction content within the rectangular box?