guides/sahi-tiled-inference/

[giscus[bot]]

guides/sahi-tiled-inference/

A comprehensive guide on how to use YOLOv8 with SAHI for standard and sliced inference in object detection tasks.

https://docs.ultralytics.com/guides/sahi-tiled-inference/

[baozh166]

I am using SAHI's Batch Prediction to predict large images (150000*150000). I need to set the --agnostic-nms=True in the Yolov8 to avoid multiple classes being detected for single object. But the SAHI's batch predict function does not accept --agnostic-nms argument for Yolov8. Is there a way to deal with this issue?

[glenn-jocher]

Hey there! 👋

For integrating --agnostic-nms=True with SAHI's batch prediction, you can directly set the agnostic_nms parameter when creating the AutoDetectionModel instance. Here's a quick example:

from sahi import AutoDetectionModel

# Create a YOLOv8 model with agnostic NMS enabled
detection_model = AutoDetectionModel.from_pretrained(
    model_type='yolov8',
    model_path='path/to/yolov8n.pt',
    confidence_threshold=0.3,
    device="cpu",  # or 'cuda:0'
    agnostic_nms=True,
)

Now, when you use detection_model for batch prediction with SAHI, it will apply agnostic NMS during inference. Hope this helps! 😊

Let me know if you have any more questions.

[Sachi9soni]

Hey I was trying SAHI with triton server inference

So I was unable to do it
My methodology is

detection_model = AutoDetectionModel.from_pretrained(
model_type='yolov8',
model_path='http://localhost:8000/yolo'
confidence_threshold=0.3,
device="cpu", # or 'cuda:0')

[baozh166]

I figured out a way to address this issue.

1. Make sure "agnostic-nms=true" in your customer-data-trained Yolov8's args.yaml configuration file.
2. Assign the path of this args.yaml to the model_config_path parameter of SAHI's predict().
3. Set "postprocess_class_agnostic=True" in SAHI's predict().

An example of parameters in SAHI's predict() looks like:

model_path="2-3images_640x640.v1i.yolov8/results_v8x/200_epochs-/weights/best.pt"
model_config_path="2-3images_640x640.v1i.yolov8/results_v8x/200_epochs-/args_for_sahi.yaml" # agnostic_nms=True in the .yaml file
images_dir = "/fullsize_images/in_test/"

predict(
model_type="yolov8",
model_path=model_path,
model_config_path=model_config_path,
model_device="cuda:0", # "cpu" or 'cuda:0'
model_confidence_threshold=0.6,
postprocess_class_agnostic=True,
source=images_dir,
slice_height=640,
slice_width=640,
overlap_height_ratio=0.2,
overlap_width_ratio=0.2,
visual_bbox_thickness=1,
visual_text_size=0.5,
visual_text_thickness=1,
export_pickle=True
)

[glenn-jocher]

@baozh166 hey there! Great job figuring out a solution for the agnostic NMS issue with SAHI and YOLOv8. 👍 Your approach to modify the args.yaml and use the postprocess_class_agnostic parameter in SAHI's predict() function is spot on.

For anyone else encountering a similar issue, here's a quick recap of the solution:

from sahi.predict import predict

# Set your model and config paths
model_path = "path/to/your/model/best.pt"
model_config_path = "path/to/your/config/args_for_sahi.yaml"  # agnostic_nms=True in this file

# Set your images directory
images_dir = "/path/to/your/images/"

# Run SAHI's predict function with the necessary parameters
predict(
    model_type="yolov8",
    model_path=model_path,
    model_config_path=model_config_path,
    model_device="cuda:0",  # or "cpu"
    model_confidence_threshold=0.6,
    postprocess_class_agnostic=True,
    source=images_dir,
    slice_height=640,
    slice_width=640,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
    # ... other parameters as needed
)

Remember to ensure that agnostic_nms is set to true in your YOLOv8 args.yaml file. This will help prevent multiple classes from being detected for a single object. Happy detecting! 😊

If you need further assistance, feel free to reach out!

[Bharathteja07]

How to use SAHI predict in case of incoming images on-the-fly, rather than processing a batch of images from a folder, and Infered images needs to be visualized in real-time.

[glenn-jocher]

@Bharathteja07 hey there! 👋

For real-time image processing with SAHI and YOLOv8, you can use the get_prediction function directly on your incoming image frames. Here's a quick example on how you might set it up:

from sahi.predict import get_prediction
from sahi.utils.yolov8 import download_yolov8s_model
from sahi import AutoDetectionModel

# Assuming you've already set up your model as shown in the docs
model_path = "models/yolov8s.pt"
download_yolov8s_model(model_path)
detection_model = AutoDetectionModel.from_pretrained(
    model_type='yolov8',
    model_path=model_path,
    confidence_threshold=0.3,
    device="cpu",  # or 'cuda:0' for GPU
)

# Function to process and visualize incoming images on-the-fly
def process_and_visualize(image):
    result = get_prediction(image, detection_model)
    result.export_visuals(export_dir="path/to/save/visuals/")
    # Display or further process the visualized results as needed

# Here, `image` could be frames from a video stream or any real-time image source

For real-time visualization, you might want to integrate this with a video stream processing loop, where image is replaced with frames captured from your video source. The export_visuals method saves the output, which you can then display using your preferred method, such as OpenCV's cv2.imshow for real-time display.

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

[Bharathteja07]

I tried this but inference time is high as my images are of size 5k*4k, SAHI supporting ONNX but still inference time didnt get better. I want to try engine files using SAHI but it is not available in their repo. How to proceed.

[glenn-jocher]

Hey there! 😊

For handling high-resolution images like 5k*4k, SAHI's slicing can indeed help manage the computational load, but as you've noticed, inference time can still be a challenge. If you're looking to use .engine files with SAHI for potentially better performance, here's a workaround since direct support might not be available in SAHI's repo:

1. Export YOLOv8 to ONNX: First, export your YOLOv8 model to ONNX format. This step is straightforward and well-supported.

   yolo export model=yolov8n.pt format=onnx

2. Convert ONNX to TensorRT Engine: Next, use tools like trtexec (comes with TensorRT installation) to convert the ONNX model to a TensorRT engine. This step is where you might see significant inference speed improvements.

   trtexec --onnx=yolov8n.onnx --saveEngine=yolov8n.engine

3. Integrate TensorRT Engine with SAHI: While SAHI might not directly support .engine files, you can load and run inference with the TensorRT engine in your script and then use SAHI for post-processing the results. This involves a bit of custom coding to bridge the gap between raw TensorRT inference outputs and SAHI's expected input format for result stitching.

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

import tensorrt as trt
from sahi.postprocess.combine import NmsPostprocess

# Load your TensorRT engine
# [Your code to load TensorRT engine and perform inference]

# Assuming 'detections' is the output from your TensorRT inference
# Convert 'detections' to SAHI's format
object_prediction_list = convert_to_sahi_format(detections)

# Use SAHI's NmsPostprocess for combining and post-processing
nms_postprocess = NmsPostprocess(object_prediction_list=object_prediction_list)
combined_results = nms_postprocess.run()

# Now, you can visualize or further process 'combined_results'

This approach requires a bit of manual effort to convert and handle the inference results, but it can be a powerful way to leverage the speed of TensorRT with the flexibility and utility of SAHI.

Hope this helps you proceed with your project! If you have more questions or need further assistance, feel free to ask. Happy coding! 🚀

[Zeyad-Saadawy]

I would like to use yolov8 and sahi for video detection and every time i use cv2 for video processing, the output video does not return the same detection as each frame individually if taken as image. If you can please provide a code to do it or help with the logic

[pderrenger]

@tayesh21 it sounds like you're encountering an issue where cv2-processed video frames do not yield the same detection results as individual images. This discrepancy can occur due to differences in image processing or slicing techniques when handling video streams as opposed to static images.

To ensure consistency in detection across both video frames and individual images, I recommend incorporating SAHI's sliced inference approach for video frame processing. This method involves breaking down each video frame into smaller slices, similar to how you might handle large or high-resolution single images, ensuring that detection accuracy remains high even in constrained computational environments.

Here's a quick code snippet to get you started with SAHI and YOLOv8 for video detection, focusing on video frame slicing and processing:

from sahi.predict import get_sliced_prediction
from ultralytics import YOLO

# Load your YOLOv8 model
model = YOLO("path/to/your/yolov8_model.pt")

# Define your video capture
cap = cv2.VideoCapture("path/to/your/video.mp4")

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    # Perform sliced inference on each frame
    result = get_sliced_prediction(
        image = frame,
        detection_model = model,
        slice_height = 256,
        slice_width = 256,
        overlap_height_ratio = 0.2,
        overlap_width_ratio = 0.2
    )
    
    # Here you can add code to visualize/save the detection results for each frame
    # ...

cap.release()

This example leverages SAHI's get_sliced_prediction for each frame read from the video. Adjust the slice_height, slice_width, overlap_height_ratio, and overlap_width_ratio according to your specific requirements to optimize detection performance.

Make sure to review Ultralytics Docs: Using YOLOv8 with SAHI for Sliced Inference for more details and advanced usage. Hope this helps! Let us know if you have any more questions. 🙂

[joshkulick]

In AutoDetectionModel.from_pretrained argument config should I define image_size as 640 for the best possible YOLO prediction or will YOLO preprocess the image automatically to account for this?

[glenn-jocher]

@joshkulick hey there! 👋 Great question! When using AutoDetectionModel.from_pretrained with YOLOv8, it's generally a good idea to specify the image_size that matches your model's training configuration for optimal performance. However, YOLOv8 is pretty robust and does handle image resizing internally if the input image dimensions differ from the model's expected image_size.

For the best possible YOLO predictions, using the default size (640 for many models) is a solid starting point. If you're working with images that significantly vary in size from what your model was trained on, or if you're aiming for higher accuracy in specific scenarios (like detecting small objects), adjusting the image_size might be beneficial. Just keep in mind that larger image sizes can increase processing time.

Here's a quick example on setting it:

from sahi import AutoDetectionModel

# Load the model, specify the image size if different from the default
detection_model = AutoDetectionModel.from_pretrained(
    model_type='yolov8',
    model_path='path/to/yolov8-model.pt',
    image_size=640,  # Adjust according to your needs
)

Hope this helps! If you have more questions, feel free to ask. Happy detecting! 🚀

[hardworki]

Welcome my friends, i have problem and ican not sloved it, my problem is that object names are large in images, and the borders of the box that defines the object are also large. How can I change them? Or make modifications to them? The other issue is that I only want vehicles objects, meaning cars, buses, and motorcycles. The other issue is that I previously applied Yolo in vscode. When I applied Yolo in vccode, it showed me statistical results with the number of objects. How can this option exist? With many thanks.

[pderrenger]

Hey there! 😊 Thanks for reaching out with your questions, let's tackle them one by one.

1. For large object names and box borders:
   You can adjust the size of the object names and the borders of the detected box by modifying the line thickness and font size in the code where the detections are being visualized. Here's a quick example for PyTorch:

# Assuming 'results' is the output of your model's prediction
results.render()  # Renders predictions on images
for img in results.imgs:
    img = img[:, :, ::-1]  # Convert BGR to RGB
    # Display the image, adjust window and font sizes as needed
    cv2.imshow('image', img)  
    cv2.waitKey(0)
# Note: You might need to dig into the `results.show()` or `results.save()` methods to adjust font and line thickness directly in the source code.

2. To filter only vehicle detections (cars, buses, motorcycles):
   You could filter the results based on the class names or IDs specified in your model's *.yaml file. Here's how you could do it:

car_indices = [results.names.index(n) for n in ['car', 'bus', 'motorcycle']]  # Get class indices for vehicles
vehicle_preds = [pred for pred in results.pred if pred[5] in car_indices]  # Filter predictions

3. For statistical results similar to vscode output:
   If you want to get statistical results (like count of each detected object type), you can achieve this by iterating through your detection results:

# Count each detected class
from collections import Counter
pred_names = [results.names[int(x[5])] for x in results.xyxy[0]]
count = Counter(pred_names)
print(count)

This gives you a dictionary with the object names as keys and their counts as values.

I hope this helps you out! If you have any more questions, feel free to ask. Good luck with your project! 🚀

[hardworki]

I am very grateful for your answer, but I hope that you can explain more to me based on the things that I have available. First, I use the small sized YOLO standard, and the following is the implementation code from sahi.utils.yolov8 import download_yolov8s_model
from sahi import AutoDetectionModel
from sahi.utils.cv import read_image
from sahi.utils.file import download_from_url
from sahi.predict import get_prediction, get_sliced_prediction, predict
from pathlib import Path
from IPython. display import Image

Download YOLOv8 model

yolov8_model_path = "models/yolov8s.pt"
download_yolov8s_model(yolov8_model_path)

Download test images

download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg', 'demo_data/small-vehicles1.jpeg')
download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/terrain2.png', 'demo_data/terrain2.png')
detection_model = AutoDetectionModel.from_pretrained(
model_type='yolov8',
model_path=yolov8_model_path,
confidence_threshold=0.3,
device="cpu", # or 'cuda:0'
)

With an image path

result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)

With a numpy image

result = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)

result.export_visuals(export_dir="demo/")
Image("demo/visual.png")

result = get_sliced_prediction(
"demo_data/small-vehicles1.jpeg",
detection_model,
slice_height=256,
slice_width=256,
overlap_height_ratio=0.2,
overlap_width_ratio=0.2
)
result.export_visuals(export_dir="demo_data/")
Image("demo_data/prediction_visual1.png")
Regarding the first matter, the truth is that I do not know where to put this code and how to control the measurements. I wish there were clear answers.
Also, regarding the second problem, when I execute the code, I do not have a yaml file available. Only the weights file for the model yolov8s.pt is available.
As for the third problem, I also faced a problem. I hope you can explain it based on the code sent. I also inform you that I use vscod.

[pderrenger]

Hey! Thanks for reaching out with your questions. I'm here to help! 😊

1. Placing the Code & Adjusting Box/Text Sizes: The code you've shown sets up detection pretty nicely. If you're looking to adjust the box sizes or text labels in your detections, you'd typically modify the visualization parameters in the export_visuals function call or directly in the SAHI source if needed. SAHI might not expose direct settings for text/box size, so you might consider custom drawing functions after detections for more control.

2. Filtering for Vehicles: With your current setup, there's no direct way to filter detections by class (like vehicles only) unless you modify the prediction processing code. You'd iterate through result.object_prediction_list, keep only detections of your interest (cars, buses, motorcycles), and perhaps use a custom visualization method to draw the filtered results.

3. No YAML, Only Weights: It's perfectly fine to operate with just the .pt model file for inference tasks. The SAHI and YOLO integration primarily requires the model weight file for running predictions.

4. Statistical Results in VSCode: Getting statistics like object counts involves iterating through result.object_prediction_list as mentioned. You can tally object types with standard Python collections (like Counter) for a summary. This part of processing would be manual based on the detected objects.

For VSCode-specific output or enhanced control over your detections in a development environment like VSCode, consider implementing logging or print statements that summarize result.object_prediction_list content post-prediction.

If you've got more questions or need further clarifications, feel free to ask. Happy coding!

[dimaspratama08]

I am using SAHI to predict on all present images in a folder using the predict() function, how do i get the PredictionResults object for each image? i've tried with: result = predict() and then prediction_list = results.object_prediction_list but it returns an error

[pderrenger]

Hey there! It looks like you're encountering a bit of confusion with fetching the PredictionResults for each image when using SAHI's predict() function with a directory of images. Here's a simplified approach that should help you get the results you need:

When you call the predict() function for batch processing over a directory, SAHI returns a list of PredictionResult objects, one for each image processed. To access these, you'd typically iterate through the returned list. Here’s how you can do it:

from sahi.predict import predict

# Performing batch prediction on a directory of images
results = predict(
    model_type="yolov8",
    model_path="path/to/yolov8n.pt",
    source="path/to/images/dir",
    # add other necessary args like model_device, slice_height etc.
)

# Iterating through each result
for result in results:
    object_prediction_list = result.object_prediction_list
    # Now you can work with object_prediction_list as needed for each image

Make sure your SAHI and Ultralytics installations are up to date to avoid any unexpected issues. If you're still hitting an error, could you provide the exact error message? That might offer more clues on what's going awry. 😊

Hope this clears things up! Let us know how it goes. 🚀

[dimaspratama08]

Perform batch inference

results = predict(
detection_model = detection_model,
source=source,
slice_height=4096,
slice_width=4096,
overlap_height_ratio=0.2,
overlap_width_ratio=0.2,
export_pickle = True,
visual_bbox_thickness = 10,
visual_hide_labels = True,
visual_hide_conf = True,
visual_export_format = 'jpg'
)

for result in results:
object_prediction_list = result.object_prediction_list

it still returned the same error
TypeError Traceback (most recent call last)
Cell In[42], line 1
----> 1 for result in results:
2 object_prediction_list = result.object_prediction_list

TypeError: 'NoneType' object is not iterable

[pderrenger]

Hey there! 👋 It seems like you're encountering a TypeError when trying to iterate over the results of a batch prediction with SAHI, indicating that results might be None. This usually happens when the predict() function doesn't execute as expected. It'd be helpful to double-check a few things:

1. Ensure the source is correctly pointing to a directory with images.
2. Verify that your model_type, model_path, and other parameters in predict() match your setup and the models you intend to use.
3. Make sure that SAHI and YOLOv8 installations are up to date.

Here's a small tweak for debugging purposes:

results = predict(
    model_type="yolov8",
    model_path="path/to/yolov8n.pt",
    source="path/to/images/dir",
    # your other parameters
)

# Check if 'results' is None
if results is None:
    print("No results returned. Check your source and model path.")
else:
    for result in results:
        object_prediction_list = result.object_prediction_list
        # Your code to handle the predictions

This will help you catch any immediate issues with the prediction call.

If everything seems correct but you're still facing issues, kindly share more details about the error or the setup. We're here to help! 😊

[dimaspratama08]

The source, model_type, and and path is correctly defined and it worked too, but for some reason the results is None. I don't think the parameter is the problem because when i pass the same parameter to get_sliced_prediction() function i can access the object_prediction_list

[pderrenger]

Hey there! 😊 It seems like you're running into an interesting issue where predict() returns None while get_sliced_prediction() works just fine. This behavior suggests the function might exit before compiling the results, possibly due to how input images are being handled or an internal check within predict().

Since get_sliced_prediction() is working, you're right; your parameters likely aren't the problem. It might be helpful to ensure that predict() is being used correctly in the context of batch prediction, as it's designed for processing multiple images from a directory or a list. Here's a quick snippet on how to use predict() for a directory, assuming source points to your folder with images:

from sahi.predict import predict

results = predict(
    model_type="yolov8",
    model_path="path/to/your/model.pt",
    source="path/to/your/images",
    # Other parameters as needed
)

Ensure that source is correctly pointing to the folder containing your images. If you're still encountering issues, it might be beneficial to delve deeper into SAHI's documentation or even reach out on their GitHub issues page for more specific support. There's a chance you might be hitting an edge case they can help with! 🛠️

Hope this helps a bit! Let us know if there are any improvements or further questions.

[robob80]

I have a dataset of high-resolution images; I have trained my yolo8 model on the lower resolution of size 640, so if I use my existing model with SAHI, it will still receive results based on my previous training. Is there any guidance on retraining my model so I will obtain better results?

[pderrenger]

@robob80 absolutely! Utilizing SAHI for slicing high-resolution images allows for potentially better performance with YOLOv8 models trained on lower resolutions. However, to maximize results from high-resolution images, consider retraining your model directly on higher resolution inputs when feasible. This approach could improve the model's capability to discern finer details that were not present in lower resolution training data.

For retraining, you might incrementally increase the imgsz parameter in your training command to gradually adapt your model to higher resolutions. For example:

yolo detect train data=your_dataset.yaml model=yolov8n.pt imgsz=1024 epochs=100

Ensure your dataset contains high-resolution images or adjust imgsz to the maximum resolution present in your dataset. This method helps in fine-tuning the model to better learn and detect objects from high-res images. 🚀

For more insights on integrating YOLOv8 with SAHI, our guide on sliced inference provides a comprehensive overview. Remember, the goal is to enhance detection performance while balancing computational efficiency. Best of luck with your model enhancement!

[illink7]

How I can combine SAHI with segmentation model for aerial images, could you provide me some details please

[pderrenger]

Hey there! It looks like you're trying to call .eval() on a dictionary object, which isn't possible since .eval() is a method typically used on PyTorch models to set them to evaluation mode. If you're trying to set your model to evaluation mode, make sure you're applying .eval() to your model instance, not a dictionary.

Here's a quick example to ensure you're using it correctly:

import torch

# Assuming 'model' is your loaded model instance
model = torch.load('path_to_your_model.pt')
model.eval()  # Set the model to evaluation mode

Make sure that model is indeed a PyTorch model object. If you're loading the model and it's returning a dictionary (perhaps with model state and other metadata), you'll need to properly extract the model from that dictionary. Typically, this looks something like:

model = torch.load('path_to_your_model.pt')
actual_model = model['model']  # Adjust the key according to how your model is saved
actual_model.eval()

Hope this helps! Let me know if there's anything else you need! 😊

[illink7]

thank you for your reply but unfortunately I didn't get the result I wanted or I don't understand your idea. initially I wanted to use the YOLOv8-seg model to segment aerial images. it worked for me, but along with the result there were labels and bounding boxes that hindered me. maybe there is a way to export the segmented image (data) separately or any other ideas? I am very grateful for your attention and tips, thank you so much

[pderrenger]

Hello! Thank you for your feedback and for sharing your experience with the YOLOv8-seg model. It sounds like you're looking to extract just the segmentation masks without the bounding boxes and labels. Here's a straightforward way to achieve this:

If you're using a custom script or the SAHI library for segmentation, you'll typically handle the output directly from the model's forward pass. This output often includes both the segmentation masks and the detection outputs (like bounding boxes and labels). To get just the segmentation masks, you can modify your script to save only the mask data.

Here's a basic example of how you might adjust your code to save only the segmentation masks:

import torch
from PIL import Image
import numpy as np

# Assuming 'model' is your segmentation model and 'img' is your input image
model.eval()
with torch.no_grad():
    prediction = model(img)  # Get the raw output from the model

# Assuming the segmentation mask is in 'prediction[0]' and it's a tensor
mask = prediction[0].cpu().numpy()  # Convert to numpy array if not already
mask_image = Image.fromarray((mask * 255).astype(np.uint8))  # Convert to an image
mask_image.save('path_to_save_your_mask.png')  # Save the segmentation mask

This snippet is quite generic and might need adjustments based on the exact output format of your model. If your model outputs are in a different format or include additional post-processing steps, you'll need to adapt the code accordingly.

If you need more specific guidance, please let me know more about your model's output format or any libraries you're using to handle the model outputs! 😊

[illink7]

Thank you so much

[pderrenger]

Hello! Thanks for reaching out. 🌟

If you're looking to use YOLOv8-seg for segmentation and want to export the segmented images without bounding boxes and labels, you can directly access the segmentation masks from the model's output. Here’s a quick way to do it:

import torch
from PIL import Image
import numpy as np

# Load your model and set to evaluation mode
model = torch.load(MODEL_PATH)
model.eval()

# Prepare your image
image = Image.open(IMAGE_PATH)
image = image.convert('RGB')  # Ensure image is RGB
transform = transforms.Compose([
    transforms.ToTensor(),
])
input_tensor = transform(image).unsqueeze(0)  # Add batch dimension

# Send to device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
input_tensor = input_tensor.to(device)
model = model.to(device)

# Get prediction
with torch.no_grad():
    output = model(input_tensor)

# Assuming the output is a tensor with segmentation masks
masks = output['masks'].cpu().numpy()  # Adjust based on your model output
mask_image = Image.fromarray((masks[0] * 255).astype(np.uint8))  # Convert first mask to image
mask_image.save('segmentation_output.png')  # Save the mask image

This code snippet assumes that your model outputs a dictionary with a key 'masks' containing the segmentation masks. Adjust the key based on your actual model output. This will save the segmentation masks directly, bypassing any bounding boxes or labels.

Hope this helps! Let me know if there's anything else you need. 😊

[mxxxbbbb]

When I use Sahi, the inference speed is normal in a single main thread, but when I load Sahi into one of multiple threads, it causes the inference speed to be much slower. What is the reason for this

[glenn-jocher]

Hello! It sounds like you're experiencing a slowdown when running SAHI in a multi-threaded environment. This can often happen due to the increased overhead of managing multiple threads, especially if the threads are competing for limited computational resources like CPU or GPU.

Here are a couple of suggestions to potentially improve the performance:

1. Ensure Adequate Resources: Make sure that your system has enough resources (CPU/GPU) to handle multiple threads efficiently. If each thread is performing intensive computations, you might need more powerful hardware or fewer concurrent threads.

2. Optimize Thread Management: Try to manage the number of threads based on the workload and the hardware capabilities. Sometimes, reducing the number of threads can actually improve overall performance.

3. Profile Your Application: Use profiling tools to understand where the bottlenecks are. This can provide insights into whether the issue is due to thread management, I/O operations, or something else.

If you continue to experience issues, consider providing more details about your setup, such as the hardware specifications and the specific code implementation, so we can help you better. 🚀

[mxxxbbbb]

I have loaded many deep learning models in one thread across multiple threads, among which sahi is one. When testing with a single main thread, the speed is not a problem, but with multiple threads, the speed is very slow

[mxxxbbbb]

def pre_sahi(self,img_all):

    resize_img = self.resize_long_image(img_all,640)
    t1 = time.time()
    slice_image_result = slice_image(
        image=resize_img,
        slice_height=640,
        slice_width=640,
        overlap_height_ratio=0.2,
        overlap_width_ratio=0.2,
        auto_slice_resolution=True,
    )

    result = get_sliced_prediction(
        resize_img,
        slice_image_result,
        self.model_sahi,
    )
    box = []
    t2 = time.time()
    print("time:",t2-t1)

This is my call to this class's function in a certain thread, and the model is actually loaded by the constructor

[glenn-jocher]

Hello! It sounds like you're encountering a common issue when using multiple threads for inference, especially when each thread is loading a deep learning model like SAHI. This slowdown can occur due to several reasons:

1. Resource Contention: Each thread may be competing for limited computational resources (CPU/GPU). This is particularly significant if each model in the threads is substantial in size and computational demand.

2. Global Interpreter Lock (GIL) in Python: If you're using Python, the GIL can become a bottleneck in multi-threaded applications, as it allows only one thread to execute Python bytecode at a time. This can severely limit performance when using CPU-bound tasks.

3. I/O Bottlenecks: If your application involves reading from or writing to disk, such as loading models or accessing data, I/O operations can become a bottleneck when scaled across multiple threads.

To mitigate these issues, consider the following:

• Use multiprocessing instead of multithreading: This can help bypass the GIL and better utilize multiple cores.
• Optimize resource allocation: Ensure that each thread or process has enough resources to perform its tasks efficiently.
• Load models once: If possible, load your models once and share them across threads, rather than loading them separately in each thread.

For more detailed guidance, you might find our documentation on using YOLOv8 with SAHI helpful: Using YOLOv8 with SAHI for Sliced Inference. This guide provides insights into efficiently managing resources and optimizing inference tasks.

[Rushita69]

How can I predict only the specific classes I need and not all the classes used during training in Sahi inference?

[glenn-jocher]

@Rushita69 to predict only specific classes during SAHI inference with YOLOv8, you can filter the predictions based on class IDs after the detection process. Here's a simple way to achieve this using Python:

from sahi.predict import get_sliced_prediction

# Instantiate your model as usual
detection_model = AutoDetectionModel.from_pretrained(
    model_type="yolov8",
    model_path="path/to/yolov8_model.pt",
    confidence_threshold=0.3,
    device="cpu",  # or 'cuda:0'
)

# Perform sliced prediction
result = get_sliced_prediction(
    image_path="path/to/image.jpeg",
    detection_model=detection_model,
    slice_height=256,
    slice_width=256,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)

# Filter predictions to include only specific classes, e.g., class IDs 1 and 3
filtered_predictions = [pred for pred in result.object_prediction_list if pred.category_id in [1, 3]]

# Now you can use filtered_predictions as needed

This code snippet will help you filter out detections and keep only those that belong to the classes you're interested in. For more detailed guidance on using YOLOv8 with SAHI, you can refer to our comprehensive guide here.

[ChongCheeKaiClarence]

Hi, I need help inresolving this.

ModuleNotFoundError: No module named 'sahi.predict'; 'sahi' is not a package

This is my package environment

asttokens           2.0.5
backcall            0.2.0
Brotli              1.0.9
certifi             2024.2.2
cffi                1.16.0
charset-normalizer  2.0.4
click               8.1.7
colorama            0.4.6
contourpy           1.1.1
cycler              0.12.1
decorator           5.1.1
executing           0.8.3
filelock            3.13.1
fire                0.6.0
fonttools           4.51.0
fsspec              2024.3.1
gmpy2               2.1.2
idna                3.7
importlib_resources 6.4.0
intel-openmp        2021.4.0
ipython             8.12.2
jedi                0.18.1
Jinja2              3.1.3
kiwisolver          1.4.5
MarkupSafe          2.1.3
matplotlib          3.7.5
matplotlib-inline   0.1.6
mkl                 2021.4.0
mkl-fft             1.3.8
mkl-random          1.2.4
mkl-service         2.4.0
mpmath              1.3.0
networkx            3.1
numpy               1.24.3
opencv-python       4.8.1.78
packaging           24.0
pandas              2.0.3
parso               0.8.3
pickleshare         0.7.5
pillow              10.3.0
pip                 24.0
prompt-toolkit      3.0.43
psutil              5.9.8
pure-eval           0.2.2
py-cpuinfo          9.0.0
pybboxes            0.1.6
pycparser           2.21
Pygments            2.15.1
pyparsing           3.1.2
PySocks             1.7.1
python-dateutil     2.9.0.post0
pytz                2024.1
PyYAML              6.0.1
requests            2.31.0
sahi                0.11.16
scipy               1.10.1
seaborn             0.13.2
setuptools          69.5.1
shapely             2.0.1
six                 1.16.0
stack-data          0.2.0
sympy               1.12
tbb                 2021.12.0
termcolor           2.1.0
terminaltables      3.1.10
thop                0.1.1.post2209072238
torch               2.2.0
torchvision         0.18.0
tqdm                4.66.4
traitlets           5.7.1
typing_extensions   4.11.0
tzdata              2024.1
ultralytics         8.2.20
urllib3             2.2.1
wcwidth             0.2.5
wheel               0.43.0
win-inet-pton       1.1.0
zipp                3.18.2

[pderrenger]

Hi there! It looks like Python isn't recognizing sahi as an installed package, despite it appearing in your environment list. This could be due to a few reasons:

1. Environment Issue: Make sure you're activating the correct Python environment where sahi is installed if you're using virtual environments.

2. Path Issue: Python might not be looking in the correct directory for installed packages. You can verify where Python is searching for packages with:

   import sys
   print(sys.path)

3. Reinstallation: Sometimes, a simple reinstallation can fix the issue. Try:

   pip install --upgrade --force-reinstall sahi

If these steps don't resolve the issue, consider checking if there are any naming conflicts or if the installation was somehow corrupted. Let me know how it goes! 🛠️

[noval779]

I use YOLOv8 + SAHI for tree detection, I need to calculate the diameter of the tree canopy in cm/m, I read in several articles to use pixels from the bounding box and convert them into cm/m, how do I implement it in SAHI?

[pderrenger]

Hi there!

Great to hear you're using YOLOv8 + SAHI for tree detection! 🌳 To calculate the diameter of the tree canopy in cm/m, you can indeed use the pixel dimensions from the bounding box and convert them based on a known scale (e.g., pixels per meter).

Here's a concise way to implement this in SAHI:

1. Perform Sliced Inference:

   result = get_sliced_prediction(
       "demo_data/small-vehicles1.jpeg",
       detection_model,
       slice_height=256,
       slice_width=256,
       overlap_height_ratio=0.2,
       overlap_width_ratio=0.2,
   )

2. Extract Bounding Box Dimensions:

   for object_prediction in result.object_prediction_list:
       bbox = object_prediction.bbox
       width_pixels = bbox.width
       height_pixels = bbox.height
       # Assuming you have a known scale, e.g., 1 pixel = 0.5 cm
       width_cm = width_pixels * 0.5
       height_cm = height_pixels * 0.5
       print(f"Width: {width_cm} cm, Height: {height_cm} cm")

3. Convert Pixels to Real-World Units:
   Adjust the scale factor (e.g., 0.5 cm per pixel) based on your specific setup.

For more detailed guidance, you can refer to the Ultralytics Docs on SAHI.

Feel free to reach out if you have any more questions! 😊

[noval779]

Thank you for replying to my question, but an error appeared when I tried to use it "AttributeError: 'BoundingBox' object has no attribute 'width'"

[noval779]

BoundingBox: <(37.17367172241211, 2541.80712890625, 240.060546875, 2741.1326904296875), w: 202.8868751525879, h: 199.3255615234375>

I have also tried changing it with w and h, but it still gives an error

[pderrenger]

@noval779 hi there!

Thanks for sharing the details. It looks like you're on the right track! The BoundingBox object in SAHI indeed doesn't have direct width and height attributes. Instead, you can access the bounding box coordinates and calculate the dimensions.

Here's how you can do it:

for object_prediction in result.object_prediction_list:
    bbox = object_prediction.bbox
    x_min, y_min, x_max, y_max = bbox.minx, bbox.miny, bbox.maxx, bbox.maxy
    width_pixels = x_max - x_min
    height_pixels = y_max - y_min
    # Assuming you have a known scale, e.g., 1 pixel = 0.5 cm
    width_cm = width_pixels * 0.5
    height_cm = height_pixels * 0.5
    print(f"Width: {width_cm} cm, Height: {height_cm} cm")

This should help you convert the bounding box dimensions from pixels to cm/m. If you have any further questions, feel free to ask! 😊