Skip to content

Eran Feit : Computer-Vision Hub
Tutorials
Blog
Contact page
Travel
HTML Sitemap

Buy me a coffee

Buy me a coffee

Home
My blog post
Image Classification
Object Detection
Image Segmentation
Unet
OpenCV
Python Cool Stuff
Jetson Nano
TensorFlow tutorials
Travel
Contact
HTML Sitemap

YOLOv8 Small Object Detection with SAHI in Python (Sliced Inference)

/ Object Detection, Pytorch

Contents hide

1 Why YOLOv8 small object detection is so important today

1.1 🚀 Recommended for You:

2 Getting hands-on with YOLOv8 small object detection

2.1 New to YOLOv8? Start with these beginner-friendly guides

2.2 Master Computer Vision

3 How to Detect Small Objects with YOLOv8 and SAHI

4 SAHI Slice Settings That Actually Work for Small Objects

4.1 Quick Checklist: When SAHI Helps (and When It Doesn’t)

5 Setting up the environment for YOLOv8 and SAHI

5.1 Next steps: full YOLOv8 custom object detection projects

6 Loading YOLOv8, preparing the image, and configuring SAHI

6.1 Turn better detections into powerful segmentation pipelines

7 Running YOLOv8 and SAHI to get predictions

8 Drawing bounding boxes and visualizing the results

9.1 Explore more object detection models after YOLOv8 + SAHI

Last Updated on 22/04/2026 by Eran Feit

YOLOv8 small object detection with SAHI is one of the fastest ways to improve detections when targets are tiny (distant cars, small drones, pests on leaves) and full-image inference keeps missing them.
In this tutorial, you’ll build a repeatable Python script that runs two passes on the same image: standard YOLOv8 inference, and then SAHI sliced inference (tiling + merging).

The key idea is simple: slicing gives small objects more pixels per tile, so YOLO’s features don’t collapse them during downsampling.
You’ll learn the practical knobs that actually matter—slice size, overlap ratio, confidence threshold, and merge behavior—and you’ll see the results visually in OpenCV so you can judge whether slicing is worth the speed tradeoff for your use case.By the end, you’ll have a clean baseline, a SAHI-enhanced pipeline, and a short checklist for tuning slices for traffic cameras, aerial imagery, and any high-resolution scene where “small” objects decide whether the system works.What you’ll get from this post
– A clean Conda setup (GPU or CPU).
– A minimal YOLOv8 baseline inference.
– SAHI sliced inference with recommended starter parameters.
– Side-by-side visualization so you can compare results honestly.

Yolo Sahi

Yolo Sahi

Why YOLOv8 small object detection is so important todayThe main goal of YOLOv8 small object detection is to accurately find and label very small targets in large or complex images without sacrificing real-time performance. In many practical systems, the most critical objects are also the smallest: a pedestrian far from the camera in an ADAS system, a tiny UAV in a wide sky, or insects scattered across high-resolution crop images. Missing these targets is not just a minor accuracy issue; it can break an entire application. Making YOLOv8 sensitive to these small patterns while keeping latency low is therefore a key requirement for real deployments.At a high level, YOLOv8 is built around three main blocks: a backbone that extracts visual features, a neck that fuses multi-scale information, and a head that predicts bounding boxes and class scores. This architecture is designed to capture objects at different sizes by aggregating features at multiple resolutions. YOLOv8 also introduces improvements over earlier YOLO versions, such as an anchor-free head and optimized feature fusion, which help it adapt better to diverse object scales and complex backgrounds.However, even with a strong architecture, standard full-image inference has limits when objects shrink below a certain size. Downsampling and pooling can compress a tiny car or drone into just a handful of activations, making it easy for the network to ignore. That is where sliced inference comes in. SAHI extends the pipeline by splitting the original image into overlapping tiles, running YOLO on each tile at a higher effective resolution, and then mapping all predictions back to the original coordinates. This technique gives small objects more pixels and clearer context, which significantly boosts their detection accuracy without needing to retrain the core model.In practice, a YOLOv8 small object detection workflow often means loading a pretrained YOLOv8 model, wrapping it with SAHI’s sliced inference utilities, and tuning parameters such as slice size, overlap ratio, and confidence thresholds. The heavy lifting—running detection on each patch and merging duplicate boxes—is handled automatically by the library. This allows you to focus on dataset choice, evaluation metrics, and visualization rather than manually implementing tiling logic yourself. It also scales well: the same approach can be reused across different domains, from traffic analytics to agriculture or marine monitoring, wherever small objects play an outsized role. 🚀 Recommended for You:Ready to take your object detection skills to the next level? Learn how to handle live data with our latest guide: YouTube Stream Frame Extraction and Real-Time YOLOv8 Detection .

Eliminate stream lag with advanced buffer management.

Connect YOLOv8 directly to any YouTube URL.

Optimized for low-latency real-time inference.

YOLOv8 small object detection with SAHI

YoloV8 small object detection

Getting hands-on with YOLOv8 small object detectionThis tutorial is all about turning the theory of YOLOv8 small object detection into a simple, repeatable Python script you can actually run.
Instead of starting from a huge framework, the code focuses on a single, clear use case: detecting cars and other objects in an image where some targets are relatively small or far from the camera.
The goal is to show you how to set up the environment, load a pretrained YOLOv8 model, combine it with SAHI, and visually compare “normal” detection to sliced inference on the same image.The code begins with the practical foundations: creating a dedicated Conda environment, installing PyTorch with CUDA support, and then adding the ultralytics and sahi libraries.
This makes the script self-contained and easy to debug, because all dependencies live in a clean environment tailored for object detection work.
Once the environment is ready, the script downloads the YOLOv8 medium model, so you can start experimenting without training your own network.From there, the tutorial walks through a straightforward inference pipeline.
An input image is loaded with OpenCV, resized to a more manageable scale, and passed once through YOLOv8 for a standard “full image” prediction.
You see how easy it is to run model(img) and get annotated results that already detect cars and other visible objects.
This part of the code sets a baseline: what YOLOv8 can do on its own, without any special tricks for small objects.The second half of the script introduces SAHI and its sliced prediction workflow.
Instead of feeding the entire image at once, the code uses get_sliced_prediction to cut the image into overlapping tiles, run YOLOv8 on each tile, and then merge all predictions back together.
This effectively zooms in on small objects, giving them more pixels and a better chance to be detected.
You then loop over the resulting bounding boxes, draw them with OpenCV, and display a side-by-side comparison of the simple YOLOv8 output versus the YOLOv8+SAHI output.
The final result is a compact tutorial script that shows, in a very visual way, how sliced inference can significantly improve YOLOv8 small object detection on real images.

New to YOLOv8? Start with these beginner-friendly guides

If you want a gentle introduction before diving into YOLOv8 small object detection with SAHI, these tutorials walk through the basics step by step:

Complete YOLOv8 Classification Tutorial For Beginners
YOLOv8 Tutorial: Build a Car Image Classifier

Link to the video tutorial : https://youtu.be/e0nsRGwd82sYou can download the code here : https://eranfeit.lemonsqueezy.com/buy/e102b217-e1a1-4a35-aabe-88eb8ddaf685 or here : https://ko-fi.com/s/44116d7409Link to medium users : https://medium.com/@feitgemel/how-to-detect-small-objects-with-yolov8-and-sahi-67702073c612

Photo GPT AI Editor

Master Computer Vision

Follow my latest tutorials and AI insights on my Personal Blog.

Bootcamp

Beginner

Complete CV Bootcamp

Foundation using PyTorch & TensorFlow.

Get Started →

PyTorch

Interactive

Deep Learning with PyTorch

Hands-on practice in an interactive environment.

Start Learning →

GPT OpenCV

Advanced

Modern CV: GPT & OpenCV4

Vision GPT and production-ready models.

Go Advanced →

How to Detect Small Objects with YOLOv8 and SAHIYOLOv8 small object detection becomes really interesting when you move from “big and obvious” objects to tiny cars, people, or drones that occupy just a few pixels in a large image.
In those cases, even a strong detector can miss targets simply because there is not enough detail after downsampling.This tutorial shows a practical way to handle that problem by combining YOLOv8 with SAHI (Slicing Aided Hyper Inference).
You will first run a simple YOLOv8 prediction on a full image and then use SAHI to slice the same image into overlapping tiles, detect objects on each tile, and merge the results.The code walks through the full pipeline: creating a clean Conda environment, installing PyTorch with CUDA, adding YOLOv8 and SAHI, downloading a pretrained YOLOv8 model, and finally drawing bounding boxes with OpenCV.
By the end of this post you will have a clear, copy-paste friendly script that visually compares plain YOLOv8 detection against a YOLOv8+SAHI sliced setup for small object detection.SAHI Slice Settings That Actually Work for Small ObjectsSmall object detection usually fails for one simple reason: the object is too tiny after the model downsamples the image.
SAHI solves this by cutting the image into overlapping tiles, so small targets become “bigger” inside each tile.
But SAHI isn’t magic—if the slice size and overlap are wrong, you either miss objects at tile borders or you get duplicate detections and slow inference.Here are three practical presets that work well as a starting point.
You can copy one preset, run it once, and then tune in small steps instead of guessing.
The right preset depends mostly on how small the objects are relative to the full image and how much speed you can afford to lose.Preset A (Balanced default for most cases)
Use this when objects are small but not extreme, and you want decent speed.
Start with a slice size that matches common YOLO input sizes and a moderate overlap.
Recommended: slice_height=640, slice_width=640, overlap_height_ratio=0.2, overlap_width_ratio=0.2.Preset B (Very small objects, higher recall)
Use this when you’re missing objects consistently in full-image inference.
Smaller slices increase the object’s pixel footprint inside each tile, but inference becomes slower.
Recommended: slice_height=512, slice_width=512, overlap_height_ratio=0.25, overlap_width_ratio=0.25.Preset C (Very large images, keep it efficient)
Use this when the images are very high resolution (e.g., 4K cameras) and you want a reasonable tradeoff.
Larger tiles reduce the total number of slices and speed things up, but may reduce gains for tiny targets.
Recommended: slice_height=1024, slice_width=1024, overlap_height_ratio=0.15, overlap_width_ratio=0.15.A simple way to tune this without overthinking is to change one variable at a time.
If you still miss objects near the borders of tiles, increase overlap by +0.05.
If you get too many duplicates or the run becomes too slow, decrease overlap by -0.05 or increase sliceQuick Checklist: When SAHI Helps (and When It Doesn’t)SAHI helps when your objects are small in the full image and the baseline model misses them.
It also helps when your images are high resolution and objects occupy only a few pixels.
SAHI is less useful when objects are already medium/large, or when speed is your top priority and you can’t afford tiling overhead.Setting up the environment for YOLOv8 and SAHIBefore writing any Python, it is best to isolate the project in its own Conda environment.
This keeps your YOLOv8 small object detection experiments clean, reproducible, and independent from other projects on the same machine.In this first block you will create and activate a Conda environment, check that CUDA is available, install a CUDA-enabled PyTorch stack, and then add the Ultralytics YOLOv8 and SAHI libraries.
Once this is done, you are ready to run the rest of the tutorial code on GPU or CPU without version conflicts.

### Create a new Conda environment dedicated to YOLOv8 small object detection with SAHI.
conda create --name yolo8_sahi python=3.8

### Activate the environment so that all packages are installed in an isolated space.
conda activate yolo8_sahi

### Check that the NVIDIA CUDA compiler is available and confirm the installed CUDA toolkit version.
nvcc --version

### Install PyTorch, Torchvision, and Torchaudio with CUDA 11.8 support from the official PyTorch and NVIDIA channels.
conda install pytorch==2.1.1 torchvision==0.16.1 torchaudio==2.1.1 pytorch-cuda=11.8 -c pytorch -c nvidia

### Install the Ultralytics package that provides the YOLOv8 implementation used in this tutorial.
pip install ultralytics==8.1.0

### Install the SAHI library, which adds sliced inference for better small object detection.
pip install sahi

### Create a new Conda environment dedicated to YOLOv8 small object detection with SAHI. conda create --name yolo8_sahi python=3.8  ### Activate the environment so that all packages are installed in an isolated space. conda activate yolo8_sahi  ### Check that the NVIDIA CUDA compiler is available and confirm the installed CUDA toolkit version. nvcc --version  ### Install PyTorch, Torchvision, and Torchaudio with CUDA 11.8 support from the official PyTorch and NVIDIA channels. conda install pytorch==2.1.1 torchvision==0.16.1 torchaudio==2.1.1 pytorch-cuda=11.8 -c pytorch -c nvidia  ### Install the Ultralytics package that provides the YOLOv8 implementation used in this tutorial. pip install ultralytics==8.1.0  ### Install the SAHI library, which adds sliced inference for better small object detection. pip install sahi

After running these commands you have a clean environment configured for YOLOv8 small object detection with SAHI.
If anything breaks later, you can simply recreate the same environment with these few lines.

Next steps: full YOLOv8 custom object detection projects

Once your environment is ready, you can reuse it for end-to-end YOLOv8 training projects on your own datasets:

How to Train YOLOv8 Object Detection on a Custom Dataset: Cards Detection
How to Build YOLOv8 Dental Object Detection Model
Browse all my Object Detection tutorials

Loading YOLOv8, preparing the image, and configuring SAHINow that the environment is ready, the next step is to load the required libraries, download a pretrained YOLOv8 model, and prepare the input image.
In this tutorial, the target is to detect cars and other objects in an image where some of them are relatively small or far away from the camera.The code below imports OpenCV, SAHI utilities, and the YOLO class from Ultralytics.
It then points to a local image, sets the model path, downloads the YOLOv8m weights if they are not already present, and wraps the model in a SAHI AutoDetectionModel configured with a confidence threshold and device selection.
Finally, it loads the original image with OpenCV, scales it down to a more manageable size, and keeps a resized copy ready for the next steps.Here is our test image :

YOLOv8 small object detection with SAHI

YOLOv8 Small Object Detection with SAHI in Python (Sliced Inference) 11

### Import OpenCV so we can load images, resize them, draw bounding boxes, and display windows.
import cv2 

### Import the AutoDetectionModel wrapper from SAHI to connect YOLOv8 with sliced inference.
from sahi import AutoDetectionModel 

### Import the get_sliced_prediction helper to run SAHI’s tiled small object detection.
from sahi.predict import get_sliced_prediction

### Import a convenience function that downloads the YOLOv8m model weights if needed.
from sahi.utils.yolov8 import download_yolov8m_model

### Import the YOLO class from Ultralytics so we can run standard YOLOv8 inference.
from ultralytics import YOLO 

### Define the path to the input image that contains cars and other objects we want to detect.
img_path = "Best-Object-Detection-models/Yolo-V8/yolov8-sahi-Detect-Objects/cars.jpg"

### Define the filename of the YOLOv8 model we plan to use.
model_path = "yolov8m.pt"

### Build the full path where the YOLOv8 model file will be stored locally.
yolov8_model_path = f'models/{model_path}'

### Download the YOLOv8m model weights into the models folder if they are not already there.
download_yolov8m_model(yolov8_model_path)

### Create a SAHI AutoDetectionModel that wraps the YOLOv8 model for sliced small object detection.
detection_model = AutoDetectionModel.from_pretrained(
    model_type='yolov8',
    model_path=yolov8_model_path,
    confidence_threshold=0.6,
    device='cpu'
)

### Load the original image from disk using OpenCV.
img_original = cv2.imread(img_path)

### Define the desired scaling percentage to shrink the image for faster experiments.
scale_precent = 30 

### Compute the new width based on the original width and the chosen scale percentage.
w = int(img_original.shape[1] * scale_precent / 100)

### Compute the new height based on the original height and the chosen scale percentage.
h = int(img_original.shape[0] * scale_precent / 100)

### Pack the resized width and height into a dimension tuple for OpenCV.
dim = (w, h)

### Resize the original image to the new dimensions using an interpolation method suited for shrinking.
img_original = cv2.resize(img_original, dim, interpolation=cv2.INTER_AREA)

### Import OpenCV so we can load images, resize them, draw bounding boxes, and display windows. import cv2   ### Import the AutoDetectionModel wrapper from SAHI to connect YOLOv8 with sliced inference. from sahi import AutoDetectionModel   ### Import the get_sliced_prediction helper to run SAHI’s tiled small object detection. from sahi.predict import get_sliced_prediction  ### Import a convenience function that downloads the YOLOv8m model weights if needed. from sahi.utils.yolov8 import download_yolov8m_model  ### Import the YOLO class from Ultralytics so we can run standard YOLOv8 inference. from ultralytics import YOLO   ### Define the path to the input image that contains cars and other objects we want to detect. img_path = "Best-Object-Detection-models/Yolo-V8/yolov8-sahi-Detect-Objects/cars.jpg"  ### Define the filename of the YOLOv8 model we plan to use. model_path = "yolov8m.pt"  ### Build the full path where the YOLOv8 model file will be stored locally. yolov8_model_path = f'models/{model_path}'  ### Download the YOLOv8m model weights into the models folder if they are not already there. download_yolov8m_model(yolov8_model_path)  ### Create a SAHI AutoDetectionModel that wraps the YOLOv8 model for sliced small object detection. detection_model = AutoDetectionModel.from_pretrained(     model_type='yolov8',     model_path=yolov8_model_path,     confidence_threshold=0.6,     device='cpu' )  ### Load the original image from disk using OpenCV. img_original = cv2.imread(img_path)  ### Define the desired scaling percentage to shrink the image for faster experiments. scale_precent = 30   ### Compute the new width based on the original width and the chosen scale percentage. w = int(img_original.shape[1] * scale_precent / 100)  ### Compute the new height based on the original height and the chosen scale percentage. h = int(img_original.shape[0] * scale_precent / 100)  ### Pack the resized width and height into a dimension tuple for OpenCV. dim = (w, h)  ### Resize the original image to the new dimensions using an interpolation method suited for shrinking. img_original = cv2.resize(img_original, dim, interpolation=cv2.INTER_AREA)

At this point you have a resized image in memory and a YOLOv8 model that can be used both for simple full-image prediction and for SAHI-powered sliced inference.
The confidence threshold and device can easily be adjusted later if you move from CPU to GPU or want stricter filtering of low probability detections.

Turn better detections into powerful segmentation pipelines

If you enjoy improving YOLOv8 small object detection with SAHI, you might also like these tutorials that push YOLOv8 further with auto-labeling and segmentation:

Boost Your Dataset With YOLOv8 Auto-Label Segmentation
YOLOv8 Dog Segmentation Tutorial: Learn Precise Object Masks
YOLOv8 Segmentation Tutorial for Multi-Class Football
YOLOv8 Flood Segmentation Tutorial for Real Map Images

Running YOLOv8 and SAHI to get predictionsIn this part we focus on the actual detection step.
First, we run a simple YOLOv8 inference on the resized image to get a baseline prediction.
Then we apply SAHI’s sliced inference on a copy of the same image and convert the resulting objects into two simple Python lists: one for bounding box coordinates and one for class names.
These lists will be used in the next part to draw bounding boxes and labels on the image.

### Make a copy of the resized image that will be used for the plain YOLOv8 prediction.
img2 = img_original.copy()

### Load the YOLOv8 model from the local model file so we can run standard object detection.
model = YOLO(model_path)

### Run YOLOv8 inference on the image copy with a confidence threshold of 0.6.
results = model(img2, conf=0.6)

### Convert the first YOLOv8 result into an annotated frame with bounding boxes and labels.
annotated_frame = results[0].plot()

### Make another copy of the resized image that will be used for YOLOv8 + SAHI sliced inference.
img = img_original.copy() 

### Run SAHI sliced prediction on the image using the wrapped YOLOv8 detection model.
results = get_sliced_prediction(
    img,
    detection_model,
    slice_height=512,
    slice_width=512,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2
)

### Extract the list of individual object predictions produced by SAHI.
object_predicition_list = results.object_prediction_list

### Prepare an empty list to store bounding box coordinates for each detected object.
boxes_list = []

### Prepare an empty list to store the class names for each detected object.
clss_list = [] 

### Loop over each object prediction in the SAHI result.
for ind, _ in enumerate(object_predicition_list):

    ### Extract the bounding box coordinates (min x, min y, max x, max y) for the current prediction.
    boxes = (
        object_predicition_list[ind].bbox.minx,
        object_predicition_list[ind].bbox.miny,
        object_predicition_list[ind].bbox.maxx,
        object_predicition_list[ind].bbox.maxy
    )

    ### Extract the category name (class label) for the current prediction.
    clss = object_predicition_list[ind].category.name 

    ### Append the bounding box coordinates to the list of boxes.
    boxes_list.append(boxes)

    ### Append the class name to the list of class labels.
    clss_list.append(clss)

### Print the list of detected class names to the console for a quick sanity check.
print(clss_list)

### Make a copy of the resized image that will be used for the plain YOLOv8 prediction. img2 = img_original.copy()  ### Load the YOLOv8 model from the local model file so we can run standard object detection. model = YOLO(model_path)  ### Run YOLOv8 inference on the image copy with a confidence threshold of 0.6. results = model(img2, conf=0.6)  ### Convert the first YOLOv8 result into an annotated frame with bounding boxes and labels. annotated_frame = results[0].plot()  ### Make another copy of the resized image that will be used for YOLOv8 + SAHI sliced inference. img = img_original.copy()   ### Run SAHI sliced prediction on the image using the wrapped YOLOv8 detection model. results = get_sliced_prediction(     img,     detection_model,     slice_height=512,     slice_width=512,     overlap_height_ratio=0.2,     overlap_width_ratio=0.2 )  ### Extract the list of individual object predictions produced by SAHI. object_predicition_list = results.object_prediction_list  ### Prepare an empty list to store bounding box coordinates for each detected object. boxes_list = []  ### Prepare an empty list to store the class names for each detected object. clss_list = []   ### Loop over each object prediction in the SAHI result. for ind, _ in enumerate(object_predicition_list):      ### Extract the bounding box coordinates (min x, min y, max x, max y) for the current prediction.     boxes = (         object_predicition_list[ind].bbox.minx,         object_predicition_list[ind].bbox.miny,         object_predicition_list[ind].bbox.maxx,         object_predicition_list[ind].bbox.maxy     )      ### Extract the category name (class label) for the current prediction.     clss = object_predicition_list[ind].category.name       ### Append the bounding box coordinates to the list of boxes.     boxes_list.append(boxes)      ### Append the class name to the list of class labels.     clss_list.append(clss)  ### Print the list of detected class names to the console for a quick sanity check. print(clss_list)

After this block finishes, you already have detections from both plain YOLOv8 and YOLOv8+SAHI.
The boxes_list and clss_list variables hold everything you need to visualize and compare small object detections in a clear way.Drawing bounding boxes and visualizing the resultsNow that we have the predictions collected, this part is all about visualization.
We loop over each bounding box and class label, draw a colored rectangle and a solid label background, and put readable text on top with OpenCV.
Finally, we open two windows: one for the SAHI-enhanced detections and one for the simple YOLOv8 output, so you can see how much sliced inference helps with small objects.

### Loop over each bounding box and its corresponding class name together.
for box, cls in zip(boxes_list, clss_list):

    ### Unpack the bounding box coordinates into separate variables.
    x1, y1, x2, y2 = box 

    ### Draw a rectangle around the detected object on the SAHI image copy.
    cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (56, 56, 255), 2)

    ### Convert the class label to a string so it can be drawn on the image.
    label = str(cls)

    ### Measure the size of the text in pixels so we can reserve space for a solid label background.
    t_size = cv2.getTextSize(label, 0, fontScale=0.6, thickness=1)[0]

    ### Draw a filled rectangle above the bounding box to use as a background for the label text.
    cv2.rectangle(
        img,
        (int(x1), int(y1) - t_size[1] - 3),
        (int(x1) + t_size[0], int(y1) + 3),
        (56, 56, 255),
        -1
    )

    ### Put the class label text on top of the colored rectangle using a readable font.
    cv2.putText(
        img,
        label,
        (int(x1), int(y1) - 2),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.7,
        [255, 255, 255],
        thickness=2,
        lineType=cv2.LINE_AA
    )

### Open a window that shows the YOLOv8 + SAHI sliced inference result with all drawn boxes and labels.
cv2.imshow("Yolo V8 SAHI", img)

### Open another window that shows the simple YOLOv8 prediction without SAHI for comparison.
cv2.imshow("Yolo V8 Simple prediction", annotated_frame)

### Wait indefinitely for a key press so you have time to inspect the detection windows.
cv2.waitKey(0)

### Close all OpenCV windows gracefully after a key is pressed.
cv2.destroyAllWindows()

### Loop over each bounding box and its corresponding class name together. for box, cls in zip(boxes_list, clss_list):      ### Unpack the bounding box coordinates into separate variables.     x1, y1, x2, y2 = box       ### Draw a rectangle around the detected object on the SAHI image copy.     cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (56, 56, 255), 2)      ### Convert the class label to a string so it can be drawn on the image.     label = str(cls)      ### Measure the size of the text in pixels so we can reserve space for a solid label background.     t_size = cv2.getTextSize(label, 0, fontScale=0.6, thickness=1)[0]      ### Draw a filled rectangle above the bounding box to use as a background for the label text.     cv2.rectangle(         img,         (int(x1), int(y1) - t_size[1] - 3),         (int(x1) + t_size[0], int(y1) + 3),         (56, 56, 255),         -1     )      ### Put the class label text on top of the colored rectangle using a readable font.     cv2.putText(         img,         label,         (int(x1), int(y1) - 2),         cv2.FONT_HERSHEY_SIMPLEX,         0.7,         [255, 255, 255],         thickness=2,         lineType=cv2.LINE_AA     )  ### Open a window that shows the YOLOv8 + SAHI sliced inference result with all drawn boxes and labels. cv2.imshow("Yolo V8 SAHI", img)  ### Open another window that shows the simple YOLOv8 prediction without SAHI for comparison. cv2.imshow("Yolo V8 Simple prediction", annotated_frame)  ### Wait indefinitely for a key press so you have time to inspect the detection windows. cv2.waitKey(0)  ### Close all OpenCV windows gracefully after a key is pressed. cv2.destroyAllWindows()

After running this block, you will see a clear visual comparison between the two approaches.
If your scene contains many small or distant objects, the YOLOv8+SAHI window should reveal detections that were missing or less accurate in the simple YOLOv8 view.If you want a complete YOLOv8 YouTube object detection workflow (auto-labeling, training, and live inference), follow this step-by-step guide: https://eranfeit.net/how-to-use-yolov8-for-object-detection-on-youtube-videos/The result : YOLOv8 small object detection with SAHI

YOLOv8 small object detection with SAHI

YoloV8 Object detection with and without Sahi

ConclusionYOLOv8 small object detection is a powerful tool, but it truly shines when paired with the right inference strategy.
By combining YOLOv8 with SAHI, you move beyond simple full-image predictions and give your model a better view of tiny details that would otherwise be lost during downsampling.In this tutorial you set up a dedicated Conda environment, installed GPU-ready PyTorch, and added both the Ultralytics and SAHI libraries.
You then downloaded a YOLOv8m model, wrapped it in SAHI’s AutoDetectionModel, and prepared an image that simulates a realistic scene where small objects matter.
The final comparison between plain YOLOv8 and YOLOv8+SAHI clearly shows how tiled inference can recover extra detections and sharpen bounding boxes on distant cars or other small targets.This pattern is easy to extend.
You can plug in your own YOLOv8 weights trained on custom datasets, adjust slice sizes and overlaps to match your image resolution, and even move from single images to full video pipelines.
Once you are comfortable with this workflow, YOLOv8 plus SAHI becomes a reusable building block you can apply to traffic analysis, aerial mapping, smart agriculture, medical imaging, and any project where small objects carry big importance.

Explore more object detection models after YOLOv8 + SAHI

Once you are comfortable with YOLOv8 small object detection, you can broaden your toolkit with these object detection tutorials:

SSD MobileNet V3 Object Detection Explained for Beginners
Getting Started with YOLOX for Object Detection
How to Train Detectron2 on Custom Object Detection Data

Connect :☕ Buy me a coffee — https://ko-fi.com/eranfeit🖥️ Email : feitgemel@gmail.com🌐 https://eranfeit.net🤝 Fiverr : https://www.fiverr.com/s/mB3PbbEnjoy,EranYou can follow my blog here : https://eranfeit.net/blog/ Want to get started with Computer Vision or take your skills to the next level ?If you’re just beginning, I recommend this step-by-step course designed to introduce you to the foundations of Computer Vision – Complete Computer Vision Bootcamp With PyTorch & TensorFlowIf you’re already experienced and looking for more advanced techniques, check out this deep-dive course – Modern Computer Vision GPT, PyTorch, Keras, OpenCV4

← Previous Post

Subscribe to Our Newsletter

Enter your email to receive new insights, tutorials, and project updates directly in your inbox.

Email

The form has been submitted successfully!

There has been some error while submitting the form. Please verify all form fields again.

Copyright © 2026 Eran Feit

Powered by Eran Feit

Home
My blog post
Image Classification
Object Detection
Image Segmentation
Unet
OpenCV
Python Cool Stuff
Jetson Nano
TensorFlow tutorials
Travel
Contact
HTML Sitemap