SAHI

https://obss.github.io/sahi
Admin
SAHI (Slicing Aided Hyper Inference) is an open-source framework and lightweight vision library that...
Tokens:41,397
Snippets:297
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Detectron2

Source: https://obss.github.io/sahi/guides/models

Install the Detectron2 package.

```bash
pip install detectron2
```

--------------------------------

### Clone SAHI repository and run notebooks with Jupyter

Source: https://obss.github.io/sahi/notebooks

Commands to clone the SAHI repository, install development dependencies using uv, and start Jupyter Notebook in the demo directory.

```bash
git clone https://github.com/obss/sahi.git
cd sahi
uv sync --group dev
jupyter notebook demo/
```

--------------------------------

### Install Ultralytics

Source: https://obss.github.io/sahi/guides/models

Install the Ultralytics package to use YOLO models with SAHI.

```bash
pip install ultralytics
```

--------------------------------

### Install MMDetection dependencies

Source: https://obss.github.io/sahi/guides/models

Install the required packages for MMDetection support.

```bash
pip install mmdet mmcv mmengine
```

--------------------------------

### Install LibreYOLO

Source: https://obss.github.io/sahi/guides/models

Install the libreyolo package to use LibreYOLO models.

```bash
pip install libreyolo
```

--------------------------------

### Install Core and Dev Dependencies with uv sync

Source: https://obss.github.io/sahi/contributing

Install core and development dependencies using uv sync. Additional dependencies for specific models may be needed for testing.

```bash
# Install core + dev dependencies
uv sync --group dev

# For testing specific models, install their dependencies.
```

--------------------------------

### Install TorchVision

Source: https://obss.github.io/sahi/guides/models

Install torch and torchvision to use built-in TorchVision detection models.

```bash
pip install torch torchvision
```

--------------------------------

### Example output of `sahi env`

Source: https://obss.github.io/sahi/cli

Example output of the `sahi env` command, showing version information for torch, torchvision, ultralytics, transformers, timm, and fiftyone.

```text
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   torch version 2.1.2 is available.
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   torchvision version 0.16.2 is available.
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   ultralytics version 8.3.86 is available.
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   transformers version 4.49.0 is available.
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   timm version 0.9.1 is available.
06/19/2022 21:24:52 - INFO - sahi.utils.import_utils -   fiftyone version 0.14.2 is available.
```

--------------------------------

### Install HuggingFace dependencies

Source: https://obss.github.io/sahi/guides/models

Install the required packages for using HuggingFace models with SAHI.

```bash
pip install transformers timm
```

--------------------------------

### Create a Python 3.10 Virtual Environment with uv

Source: https://obss.github.io/sahi/contributing

Install uv, create a virtual environment with Python 3.10, and activate it. On Windows, use .venv\Scripts\activate instead.

```bash
pip install uv
uv venv --python 3.10
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
```

--------------------------------

### Install SAHI with Ultralytics extra

Source: https://obss.github.io/sahi/quick-start

Installs SAHI with the Ultralytics detector extra. SAHI ships without a detector, so choose the extra matching your framework: ultralytics, transformers, yolov5, roboflow, torchvision, torch, onnx, numba, or all. Conda users can instead run `conda install -c conda-forge sahi` and install the framework separately.

```bash
pip install "sahi[ultralytics]"
```

--------------------------------

### Install yolov5 package

Source: https://obss.github.io/sahi/guides/models

Install the yolov5 pip package for YOLOv5 models.

```bash
pip install yolov5
```

--------------------------------

### Install Roboflow RF-DETR

Source: https://obss.github.io/sahi/guides/models

Install the rfdetr package for Roboflow RF-DETR support.

```bash
pip install rfdetr
```

--------------------------------

### Display SAHI version

Source: https://obss.github.io/sahi/cli

Displays the currently installed SAHI version. Run this command in a terminal after installing SAHI.

```bash
sahi version
```

--------------------------------

### Install and run SAHI COCO evaluation with ultrafast backend

Source: https://obss.github.io/sahi/coco

Installs the optional ultrafast-pycocotools backend and runs the SAHI evaluation CLI with it. Requires version 0.1.11 or newer. For segmentation, add --type segm.

```bash
pip install "sahi[ultrafast]"
sahi coco evaluate --dataset_json_path coco_dataset.json \
  --result_json_path coco_predictions.json --backend ultrafast
```

--------------------------------

### Install Dev Dependencies for CI Fix

Source: https://obss.github.io/sahi/contributing

Install development dependencies after recreating the environment to fix CI formatting failures.

```bash
uv sync --group dev
```

--------------------------------

### Launch FiftyOne app with COCO dataset

Source: https://obss.github.io/sahi/fiftyone

Starts the FiftyOne interactive UI for a COCO dataset. Requires fiftyone>=0.14.2,<0.15.0. The session must be closed when done.

```python
from sahi.utils.fiftyone import launch_fiftyone_app

# Launch the FiftyOne app with your COCO dataset
session = launch_fiftyone_app(coco_image_dir, coco_json_path)

# When done, close the session
session.close()
```

--------------------------------

### Display SAHI environment versions with `sahi env`

Source: https://obss.github.io/sahi/cli

Display installed package versions related to SAHI. Outputs version information for torch, torchvision, ultralytics, transformers, timm, and fiftyone.

```bash
sahi env
```

--------------------------------

### Pin torchvision backend for full inference run with get_sliced_prediction

Source: https://obss.github.io/sahi/postprocess/backends

Sets the backend to torchvision for GPU-accelerated postprocessing, then runs a sliced prediction with AutoDetectionModel and get_sliced_prediction. Requires torch and torchvision installed and a CUDA or Apple Silicon machine.

```python
from sahi import AutoDetectionModel
from sahi.predict import get_sliced_prediction
from sahi.postprocess.backends import set_postprocess_backend

# Use GPU-accelerated postprocessing when running on a CUDA or Apple Silicon machine
set_postprocess_backend("torchvision")

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model_path="yolo26n.pt",
    confidence_threshold=0.25,
    device="cuda:0",
)

result = get_sliced_prediction(
    "image.jpg",
    detection_model,
    slice_height=512,
    slice_width=512,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)
```

--------------------------------

### Pass a pre-loaded YOLO model to AutoDetectionModel.from_pretrained

Source: https://obss.github.io/sahi/guides/models

Use this snippet when you already have a model instance (e.g., a YOLO model) and want to pass it directly to AutoDetectionModel.from_pretrained() instead of a model path. The example sets model_type to 'ultralytics', passes the yolo_model instance, sets confidence_threshold to 0.25, and device to 'cuda:0'.

```python
from ultralytics import YOLO

yolo_model = YOLO("yolo26n.pt")
# ... customize the model ...

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model=yolo_model,
    confidence_threshold=0.25,
    device="cuda:0",
)
```

--------------------------------

### Run a custom SAHI script

Source: https://obss.github.io/sahi/cli

Runs a custom script from the SAHI scripts directory. Scripts can be downloaded from the scripts directory and modified for specific needs. After installing SAHI via pip, all scripts can be called from any directory.

```bash
python script_name.py
```

--------------------------------

### Using NMSPostprocess, GreedyNMMPostprocess, and NMMPostprocess

Source: https://obss.github.io/sahi/postprocess/backends

Shows how to instantiate and apply three postprocessors: NMSPostprocess with match_threshold=0.5 and match_metric='IOU', GreedyNMMPostprocess, and NMMPostprocess. The class_agnostic flag controls whether suppression is per-category (False) or global (True).

```python
from sahi.postprocess.combine import NMSPostprocess, NMMPostprocess, GreedyNMMPostprocess

# NMS, keep the best box, discard the rest
postprocessor = NMSPostprocess(
    match_threshold=0.5,
    match_metric="IOU",
    class_agnostic=True,   # False → per-category
)
filtered = postprocessor(object_prediction_list)

# Greedy NMM, merge overlapping boxes (fast)
postprocessor = GreedyNMMPostprocess(match_threshold=0.5)
merged = postprocessor(object_prediction_list)

# Full NMM, transitive merging
postprocessor = NMMPostprocess(match_threshold=0.5)
merged = postprocessor(object_prediction_list)
```

--------------------------------

### Recreate Environment with CI Python Version

Source: https://obss.github.io/sahi/contributing

When CI fails, create a virtual environment with the Python version from the CI output and activate it.

```bash
uv venv --python 3.X  # Replace X with the version from CI
source .venv/bin/activate
```

--------------------------------

### Run sahi predict-fiftyone for sliced inference and FiftyOne visualization

Source: https://obss.github.io/sahi/cli

Runs sliced inference with default parameters and launches the FiftyOne App for interactive exploration. Requires an image directory, dataset JSON path, model path, and model config path.

```bash
sahi predict-fiftyone --image_dir image/file/or/folder \
  --dataset_json_path dataset.json \
  --model_path path/to/model \
  --model_config_path path/to/config
```

--------------------------------

### get_prediction and export methods

Source: https://obss.github.io/sahi/predict

Shows how to get a prediction and export results with custom visualization parameters or in various formats.

```APIDOC
## get_prediction

### Description
Runs prediction on an image using a detection model and returns a result object with export methods.

### Method
Python function call

### Endpoint
`from sahi.predict import get_prediction`

### Parameters
#### Function Parameters
- **image** (Image) - Required - Input image.
- **detection_model** (AutoDetectionModel) - Required - Initialized detection model.

### Request Example
```python
from sahi.predict import get_prediction
from sahi import AutoDetectionModel
from PIL import Image

# init a model
detection_model = AutoDetectionModel.from_pretrained(...)

# get prediction result
result = get_prediction(
    image,
    detection_model,
)
```

### Response
Returns a prediction result object with export methods.

## result.export_visuals

### Description
Exports the prediction result as an image with custom visualization parameters.

### Method
Python method call

### Endpoint
`result.export_visuals(...)`

### Parameters
#### Function Parameters
- **export_dir** (str) - Required - Directory to save the visualization.
- **text_size** (float) - Optional - Size of the class label text.
- **rect_th** (int) - Optional - Thickness of bounding box lines.
- **hide_labels** (bool) - Optional - Set True to hide class labels.
- **hide_conf** (bool) - Optional - Set True to hide confidence scores.
- **file_name** (str) - Optional - Name of the output file.

### Request Example
```python
result.export_visuals(
    export_dir="outputs/",
    text_size=1.0,
    rect_th=2,
    hide_labels=False,
    hide_conf=False,
    file_name="custom_visualization",
)
```

### Response
Saves the visualization file to the specified directory.

## result.to_coco_annotations

### Description
Exports the prediction result as COCO format annotations.

### Method
Python method call

### Endpoint
`result.to_coco_annotations()`

### Request Example
```python
coco_annotations = result.to_coco_annotations()
```

### Response
Returns a list of COCO annotation dictionaries.

## result.to_coco_predictions

### Description
Exports the prediction result as COCO predictions including confidence scores.

### Method
Python method call

### Endpoint
`result.to_coco_predictions(image_id=1)`

### Parameters
#### Function Parameters
- **image_id** (int) - Required - Image ID to include in predictions.

### Request Example
```python
coco_predictions = result.to_coco_predictions(image_id=1)
```

### Response
Returns a list of COCO prediction dictionaries with scores.

## result.to_imantics_annotations

### Description
Exports the prediction result in imantics format for use with the imantics library.

### Method
Python method call

### Endpoint
`result.to_imantics_annotations()`

### Request Example
```python
imantics_annotations = result.to_imantics_annotations()
```

### Response
Returns imantics annotations.

## result.to_fiftyone_detections

### Description
Exports the prediction result as FiftyOne detections for use with FiftyOne.

### Method
Python method call

### Endpoint
`result.to_fiftyone_detections()`

### Request Example
```python
fiftyone_detections = result.to_fiftyone_detections()
```

### Response
Returns FiftyOne detections.
```

--------------------------------

### nmm

Source: https://obss.github.io/sahi/postprocess/backends

Performs full non-maximum merging (NMM) on predictions. Transitive merging is applied: if A merges B and B merges C, then A gets all three.

```APIDOC
## nmm

### Description
Performs full non-maximum merging (NMM) on predictions. Transitive merging is applied: if A merges B and B merges C, then A gets all three.

### Method
Function call

### Endpoint
`from sahi.postprocess.combine import nmm`

### Parameters
- **predictions** (numpy.ndarray) - Required - An (N, 6) array with columns [x1, y1, x2, y2, score, category_id].
- **match_metric** (str) - Required - The metric to use for matching boxes. Can be "IOU" or "IOS".
- **match_threshold** (float) - Required - The threshold for considering boxes as overlapping.

### Returns
- **keep_to_merge** (dict) - A dictionary mapping kept indices to lists of merged indices.

### Example
```python
from sahi.postprocess.combine import nmm

keep_to_merge = nmm(predictions, match_metric="IOU", match_threshold=0.5)
```
```

--------------------------------

### Get a sliced prediction with SAHI AutoDetectionModel

Source: https://obss.github.io/sahi/quick-start

Runs end to end on CPU. Downloads a sample image, and Ultralytics downloads `yolo26n.pt` on first use.

```python
from sahi import AutoDetectionModel
from sahi.predict import get_sliced_prediction
from sahi.utils.file import download_from_url

download_from_url(
    "https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg",
    "demo_data/small-vehicles1.jpeg",
)

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model_path="yolo26n.pt",
)

result = get_sliced_prediction(
    image=
```

--------------------------------

### Fork and Clone the SAHI Repository

Source: https://obss.github.io/sahi/contributing

Clone your forked SAHI repository and navigate into the project directory.

```bash
git clone https://github.com/YOUR_USERNAME/sahi.git
cd sahi
```

--------------------------------

### Check and Fix Formatting with the Convenience Script

Source: https://obss.github.io/sahi/contributing

Alternative to ruff commands using the project's convenience script for checking and fixing formatting.

```bash
# Check formatting
python scripts/format_code.py check

# Fix formatting
python scripts/format_code.py fix
```

--------------------------------

### Create COCO dataset with SAHI utilities

Source: https://obss.github.io/sahi/coco

Initializes a COCO dataset, adds categories, images, annotations, and predictions, then exports to JSON files. Uses Coco, CocoCategory, CocoImage, CocoAnnotation, CocoPrediction, and save_json.

```python
from sahi.utils.coco import Coco, CocoCategory, CocoImage, CocoAnnotation, CocoPrediction
from sahi.utils.file import save_json

# Initialize a COCO dataset and add categories
coco = Coco()
coco.add_category(CocoCategory(id=0, name="human"))
coco.add_category(CocoCategory(id=1, name="vehicle"))

# Create an image entry
coco_image = CocoImage(file_name="image1.jpg", height=1080, width=1920)

# Add ground-truth annotations
coco_image.add_annotation(
    CocoAnnotation(bbox=[x_min, y_min, width, height], category_id=0, category_name="human")
)
coco_image.add_annotation(
    CocoAnnotation(bbox=[x_min, y_min, width, height], category_id=1, category_name="vehicle")
)

# Add model predictions (with confidence scores)
coco_image.add_prediction(
    CocoPrediction(score=0.86, bbox=[x_min, y_min, width, height], category_id=0, category_name="human")
)

# Add the image to the dataset
coco.add_image(coco_image)

# Export as JSON
save_json(coco.json, "coco_dataset.json")

# Export predictions in COCO result format
save_json(coco.prediction_array, "coco_predictions.json")
```

--------------------------------

### SAHI predict with real-time video visualization

Source: https://obss.github.io/sahi/cli

Enables real-time video visualization during inference with the --view_video flag. Keyboard controls: D (forward 100 frames), A (rewind 100), G (forward 20), F (rewind 20), Esc (exit). If slow, add --frame_skip_interval=20.

```bash
sahi predict --model_path yolo26s.pt --model_type ultralytics --source video.mp4 --view_video
```

--------------------------------

### Using progress_callback with get_sliced_prediction

Source: https://obss.github.io/sahi/predict

Example showing how to use the progress_callback parameter with get_sliced_prediction to receive progress updates. The callback receives 1-based indices (current, total). progress_bar is set to False to disable the tqdm bar, but both can be used together.

```python
from sahi.predict import get_sliced_prediction
from sahi import AutoDetectionModel

# init model
detection_model = AutoDetectionModel.from_pretrained(...)

def my_progress_callback(current, total):
    print(f"Processed {current}/{total} slices")

result = get_sliced_prediction(
    image,
    detection_model,
    slice_height=512,
    slice_width=512,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
    progress_bar=False,           # disable tqdm bar
    progress_callback=my_progress_callback,  # use callback to receive updates
)
```

--------------------------------

### Evaluate COCO metrics with sahi coco evaluate

Source: https://obss.github.io/sahi/cli

Calculates COCO evaluation metrics (mAP, mAR) for predictions in COCO result JSON format. Use sahi predict to generate the required result JSON. Options include --type bbox (default) or segm, --classwise for per-class scores, --max_detections (default: 500), --iou_thrs (default: 0.50:0.95 and 0.5), --out_dir, and --backend ultrafast (requires pip install "sahi[ultrafast]").

```bash
sahi coco evaluate --dataset_json_path dataset.json \
  --result_json_path result.json
```

--------------------------------

### Fix Formatting for CI

Source: https://obss.github.io/sahi/contributing

Run the convenience script to fix formatting issues that caused CI build failures.

```bash
python scripts/format_code.py fix
```

--------------------------------

### SAHI predict on video with Ultralytics model

Source: https://obss.github.io/sahi/cli

Runs SAHI predict on a video file using an Ultralytics YOLO26 model. Supports video inference with the same command structure as image inference.

```bash
sahi predict --model_path yolo26s.pt --model_type ultralytics --source video.mp4
```

--------------------------------

### Use GroundingDINO zero-shot detection model

Source: https://obss.github.io/sahi/guides/models

Load a GroundingDINO model with text_labels for fixed categories. Additional grounded phrases are appended as new categories.

```python
detection_model = AutoDetectionModel.from_pretrained(
    model_type="huggingface",
    model_path="IDEA-Research/grounding-dino-tiny",
    confidence_threshold=0.25,
    text_threshold=0.20,
    text_labels=["car", "truck", "person"],
    device="cuda:0",
)
```

--------------------------------

### Run Tests with pytest

Source: https://obss.github.io/sahi/contributing

Run all tests, a specific test file, or with coverage using pytest.

```bash
# Run all tests
uv run pytest

# Run specific test file
uv run pytest tests/test_predict.py

# Run with coverage
uv run pytest --cov=sahi
```

--------------------------------

### AutoDetectionModel.from_pretrained()

Source: https://obss.github.io/sahi/guides/models

Creates a detection model from a pretrained model. Accepts common parameters such as model_type, model_path, confidence_threshold, device, and more. Also supports passing a pre-loaded model instance directly.

```APIDOC
## AutoDetectionModel.from_pretrained()

### Description
Creates a detection model from a pretrained model. Accepts common parameters such as model_type, model_path, confidence_threshold, device, and more. Also supports passing a pre-loaded model instance directly.

### Method
from_pretrained

### Parameters
#### Common Parameters
- **model_type** (str) - Required - Framework name (e.g., ultralytics, mmdetection, etc.)
- **model_path** (str) - Optional - Path to weights file or model name. Not required if a pre-loaded model is passed.
- **config_path** (str) - Optional - Config file path (for MMDetection, Detectron2).
- **confidence_threshold** (float) - Optional - Minimum score to keep a detection (default: 0.3).
- **device** (str) - Optional - Device to use: "cpu", "cuda:0", "mps", etc.
- **category_mapping** (dict) - Optional - Map category IDs to names, keys are strings: {"0": "car", "1": "person"}.
- **category_remapping** (dict) - Optional - Remap category names after inference.
- **image_size** (int) - Optional - Override model input resolution.
- **load_at_init** (bool) - Optional - Load weights immediately (default: True).
- **model** (object) - Optional - A pre-loaded model instance (e.g., YOLO) to use directly instead of a path.

### Request Example
```python
from ultralytics import YOLO

yolo_model = YOLO("yolo26n.pt")
# ... customize the model ...

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model=yolo_model,
    confidence_threshold=0.25,
    device="cuda:0",
)
```

### Response
Returns a detection model instance ready for inference.
```

--------------------------------

### NMSPostprocess

Source: https://obss.github.io/sahi/postprocess/backends

Non-Maximum Suppression postprocessor that keeps the best box and discards overlapping ones. It can be configured with a match threshold, match metric, and class-agnostic behavior.

```APIDOC
## NMSPostprocess

### Description
Non-Maximum Suppression postprocessor that keeps the best box and discards overlapping ones. It can be configured with a match threshold, match metric, and class-agnostic behavior.

### Usage
```python
from sahi.postprocess.combine import NMSPostprocess

postprocessor = NMSPostprocess(
    match_threshold=0.5,
    match_metric="IOU",
    class_agnostic=True,   # False → per-category
)
filtered = postprocessor(object_prediction_list)
```

### Parameters
- **match_threshold** (float) - Required - Threshold for matching boxes.
- **match_metric** (str) - Required - Metric used for matching (e.g., "IOU").
- **class_agnostic** (bool) - Optional - If True, suppression is class-agnostic; if False, per-category.

### Notes
- When `class_agnostic=False`, each postprocessor runs independently per category, so a "car" prediction will never suppress a "person" prediction.
```

--------------------------------

### Detectron2 model inference with SAHI

Source: https://obss.github.io/sahi/guides/models

Load a Detectron2 model and run sliced prediction on an image.

```python
detection_model = AutoDetectionModel.from_pretrained(
    model_type="detectron2",
    model_path="path/to/model_final.pth",
    config_path="path/to/config.yaml",
    confidence_threshold=0.25,
    device="cuda:0",
)

result = get_sliced_prediction(
    "image.jpg",
    detection_model,
    slice_height=512,
    slice_width=512,
)
```

--------------------------------

### Load Ultralytics model and run sliced prediction

Source: https://obss.github.io/sahi/guides/models

Load a YOLO model using AutoDetectionModel.from_pretrained() and run sliced prediction on an image. The model_path can be a YOLO variant like yolo26n.pt. confidence_threshold and device are configurable.

```python
from sahi import AutoDetectionModel
from sahi.predict import get_sliced_prediction

detection_model = AutoDetectionModel.from_pretrained(
    model_type="ultralytics",
    model_path="yolo26n.pt",
    confidence_threshold=0.25,
    device="cuda:0",  # or "cpu"
)

result = get_sliced_prediction(
    "image.jpg",
    detection_model,
    slice_height=512,
    slice_width=512,
    overlap_height_ratio=0.2,
    overlap_width_ratio=0.2,
)
```

--------------------------------

### Sliced inference with get_sliced_prediction

Source: https://obss.github.io/sahi/predict

Initialize a detection model with AutoDetectionModel.from_pretrained for various model types (mmdet, ultralytics, huggingface, torchvision, rtdetr, librelyolo, yoloe, yolov5, yolo-world, roboflow) and then run sliced prediction on an image with slice dimensions and overlap ratios.

```python
from sahi.predict import get_sliced_prediction
from sahi import AutoDetectionModel

# init any model
detection_model = AutoDetectionModel.from_pretrained(model_type='mmdet',...) # for MMDetection models
detection_model = AutoDetectionModel.from_pretrained(model_type='ultralytics',...) # for YOLOv8/YOLO11/YOLO26 models
detection_model = AutoDetectionModel.from_pretrained(model_type='huggingface',...) # for HuggingFace detection models
detection_model = AutoDetectionModel.from_pretrained(model_type='torchvision',...) # for Torchvision detection models
detection_model = AutoDetectionModel.from_pretrained(model_type='rtdetr',...) # for RT-DETR models
detection_model = AutoDetectionModel.from_pretrained(model_type='libreyolo',...) # for LibreYOLO models
detection_model = AutoDetectionModel.from_pretrained(model_type='yoloe',...) # for YOLOE models
detection_model = AutoDetectionModel.from_pretrained(model_type='yolov5',...) # for YOLOv5 models
detection_model = AutoDetectionModel.from_pretrained(model_type='yolo-world',...) # for YOLOWorld models
detection_model = AutoDetectionModel.from_pretrained(model_type='roboflow',...) # for Roboflow RFDETR detection/segmentation models

# get sliced prediction result
result = get_sliced_prediction(
    image,
    detection_model,
    slice_height = 256,
    slice_width = 256,
    overlap_height_ratio = 0.2,
    overlap_width_ratio = 0.2
)
```

--------------------------------

### Compare multiple detection results with CLI

Source: https://obss.github.io/sahi/fiftyone

Uses the sahi coco fiftyone CLI command to visualize a dataset with multiple prediction results, ordered by misdetections. Accepts one or more result JSON files.

```bash
sahi coco fiftyone \
  --image_dir dir/to/images \
  --dataset_json_path dataset.json \
  cocoresult1.json cocoresult2.json
```
Tokens:
Raw