Supervision

https://supervision.roboflow.com/latest
Admin
Supervision is a Python library that provides reusable computer vision tools for loading datasets,...
Tokens:368,593
Snippets:2,360
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Supervision with uv

Source: https://supervision.roboflow.com/latest

Install the supervision library using uv. This is an alternative package installer for Python.

```bash
uv pip install supervision
```

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

### Install Supervision Base Package

Source: https://supervision.roboflow.com/latest/faq

Use this command to install the core Supervision library. This command installs the base package with essential utilities.

```bash
pip install supervision

```

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

### Download Example Data

Source: https://supervision.roboflow.com/latest/notebooks/zero-shot-object-detection-with-yolo-world

Downloads an example image ('dog.jpeg') and a video ('yellow-filling.mp4') to be used for object detection demonstrations. These files are saved in the HOME directory.

```bash
!wget -P {HOME} -q https://media.roboflow.com/notebooks/examples/dog.jpeg
!wget -P {HOME} -q https://media.roboflow.com/supervision/cookbooks/yellow-filling.mp4

```

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

### Install Dependencies

Source: https://supervision.roboflow.com/latest/notebooks/annotate-video-with-detections

Install the necessary Python packages, 'inference-gpu' and 'supervision', using pip. This command installs them quietly.

```bash
!pip install -q inference-gpu "supervision"

```

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

### Install Supervision from Source with uv

Source: https://supervision.roboflow.com/latest

Clone the supervision repository and install it using uv. This method is for development and utilizes uv for environment and package management.

```bash
# clone repository and navigate to root directory
git clone --depth 1 -b develop https://github.com/roboflow/supervision.git
cd supervision

# setup python environment and activate it
uv venv
source .venv/bin/activate

# installation
uv pip install -r pyproject.toml -e . --all-extras
```

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

### Install Supervision and Inference

Source: https://supervision.roboflow.com/latest/how_to/benchmark_a_model

Install the necessary libraries for benchmarking models. Ensure you use the specified version of inference for compatibility.

```bash
pip install roboflow supervision
pip install git+https://github.com/roboflow/inference.git@linas/allow-latest-rc-supervision

```

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

### Install Albumentations

Source: https://supervision.roboflow.com/latest/how_to/process_datasets

Install the Albumentations library to enable image augmentation capabilities.

```bash
pip install albumentations
```

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

### Install Supervision Package

Source: https://supervision.roboflow.com/latest/notebooks/zero-shot-object-detection-with-yolo-world

Installs the 'supervision' package, which is used for post-processing and visualizing object detection results. Ensure this is installed before proceeding with visualization steps.

```bash
!pip install -q supervision==0.19.0rc3

```

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

### Install Supervision with pip

Source: https://supervision.roboflow.com/latest

Install the supervision library using pip. This is the recommended method for most Python environments.

```bash
pip install supervision
```

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

### Install Required Libraries

Source: https://supervision.roboflow.com/latest/notebooks/serialise-detections-to-json

Installs the necessary libraries for inference, requests, tqdm, and supervision. This is a prerequisite for running the cookbook.

```bash
!pip install -q inference requests tqdm supervision

```

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

### KeyPoints Initialization Example

Source: https://supervision.roboflow.com/latest/keypoint/core

Demonstrates how to initialize a `sv.KeyPoints` object with `xy` coordinates and check its length.

```python
import numpy as np
import supervision as sv
xy = np.array([[[10, 20], [30, 40]]], dtype=np.float32)
key_points = sv.KeyPoints(xy=xy)
len(key_points)

```

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

### Install YOLO-NAS

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Install the super-gradients package to integrate YOLO-NAS models.

```bash
pip install super-gradients
```

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

### Download Example Video Asset

Source: https://supervision.roboflow.com/latest/how_to/count_in_zone

Use the supervision.assets module to download a sample video for use in tutorials.

```python
from supervision.assets import download_assets, VideoAssets

download_assets(VideoAssets.VEHICLES_2)
```

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

### Install Required Python Packages

Source: https://supervision.roboflow.com/latest/notebooks/evaluating-alignment-of-text-to-image-diffusion-models

Install the necessary Python packages for the cookbook, including diffusers for image generation, inference for object detection, and supervision for visualization. Ensure you have torch, accelerate, dill, CLIP, and YOLO-world support installed.

```bash
!pip install -q torch diffusers accelerate inference-gpu[yolo-world] dill git+https://github.com/openai/CLIP.git supervision

```

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

### Install Supervision with Metrics Extra

Source: https://supervision.roboflow.com/latest/faq

Install Supervision with optional metric dependencies using this command. This is useful when you need to use the library's advanced metric calculation features.

```bash
pip install "supervision[metrics]"

```

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

### Install Supervision and Check Version

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Installs the supervision library quietly and prints its version. This is a prerequisite for using the library's functionalities.

```python
!pip install -q supervision

import supervision as sv

print(sv.__version__)
```

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

### Install Roboflow and Supervision Packages

Source: https://supervision.roboflow.com/latest/notebooks/occupancy_analytics

Install the necessary Python packages for Roboflow model training and Supervision for data analysis and visualization. The '-q' flag suppresses verbose output.

```bash
!pip install roboflow supervision -q

```

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

### Download Example Video Asset

Source: https://supervision.roboflow.com/latest/how_to/track_objects

Downloads the 'SKIING' video asset for use in tutorials. This is a prerequisite for running the subsequent code examples.

```python
from supervision.assets import download_assets, VideoAssets

download_assets(VideoAssets.SKIING)

```

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

### Install Required Packages

Source: https://supervision.roboflow.com/latest/notebooks/small-object-detection-with-sahi

Installs the inference, supervision, and jupyter_compare_view packages. These are essential for running the object detection and visualization code in this cookbook.

```bash
%pip install inference supervision jupyter_compare_view

```

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

### PolygonAnnotator Usage Example

Source: https://supervision.roboflow.com/latest/detection/annotators

Demonstrates how to initialize the PolygonAnnotator and apply it to an image with detections.

```pycon
>>> import numpy as np
>>> import supervision as sv
>>> image = np.zeros((100, 100, 3), dtype=np.uint8)
>>> detections = sv.Detections(
...     xyxy=np.array([[20, 20, 80, 80]]),
...     class_id=np.array([0])
... )
>>> polygon_annotator = sv.PolygonAnnotator()
>>> annotated_frame = polygon_annotator.annotate(
...     scene=image.copy(),
...     detections=detections
... )
```

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

### Install Required Packages

Source: https://supervision.roboflow.com/latest/notebooks/count-objects-crossing-the-line

Install the ultralytics and supervision Python packages using pip. These libraries are essential for object detection and video analysis.

```bash
!pip install -q ultralytics supervision

```

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

### Create Images Directory

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Creates a directory named 'images' in the current working directory to store example images.

```bash
!mkdir {HOME}/images
```

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

### Install Supervision from Source with venv

Source: https://supervision.roboflow.com/latest

Clone the supervision repository and install it in a virtual environment using venv. This method is for development or when needing the latest unreleased code.

```bash
# clone repository and navigate to root directory
git clone --depth 1 -b develop https://github.com/roboflow/supervision.git
cd supervision

# setup python environment and activate it
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

# installation
pip install -e "."
```

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

### get_video_frames_generator

Source: https://supervision.roboflow.com/latest/utils/video

Get a generator that yields the frames of the video. This function allows for iterating through video frames with customizable parameters for stride, start, and end points.

```APIDOC
## get_video_frames_generator

### Description
Get a generator that yields the frames of the video.

### Parameters
- **source_path** (str): The path of the video file. Required.
- **stride** (int): Indicates the interval at which frames are returned, skipping stride - 1 frames between each. Default: 1.
- **start** (int): Indicates the starting position from which video should generate frames. Default: 0.
- **end** (int | None): Indicates the ending position at which video should stop generating frames. If None, video will be read to the end. Default: None.
```

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

### Download Example Images

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Downloads a set of sample dog images into the 'images' directory. Ensure you are in the correct directory before running.

```bash
%cd {HOME}/images

!wget -q https://media.roboflow.com/notebooks/examples/dog.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-2.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-3.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-4.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-5.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-6.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-7.jpeg
!wget -q https://media.roboflow.com/notebooks/examples/dog-8.jpeg
```

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

### Create KeyPoints from Transformers Results

Source: https://supervision.roboflow.com/latest/keypoint/core

Instantiate a KeyPoints object from the output of a Transformers model. This example assumes you have the PIL library and requests installed for image handling.

```python
from PIL import Image
import requests
import supervision as sv

```

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

### Download Example Data

Source: https://supervision.roboflow.com/latest/notebooks/underestand-visitors-with-yolo-world

Download sample image and video files for testing. Ensure the HOME environment variable is set correctly.

```bash
!wget -P {HOME} -q https://storage.googleapis.com/adonaivera_certified/test.jpeg
!wget -P {HOME} -q https://storage.googleapis.com/adonaivera_certified/test_demo1.mp4
```

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

### Integrate ByteTrack with YOLO for Video Processing

Source: https://supervision.roboflow.com/latest/trackers

This example demonstrates how to use the ByteTrack tracker with a YOLO model to process a video. It shows the setup for the model, tracker, annotators, and the callback function for frame processing.

```python
import supervision as sv
from ultralytics import YOLO

model = YOLO("<MODEL_PATH>")
tracker = sv.ByteTrack()

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

def callback(frame: np.ndarray, index: int) -> np.ndarray:
    results = model(frame)[0]
    detections = sv.Detections.from_ultralytics(results)
    detections = tracker.update_with_detections(detections)

    labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id]

    annotated_frame = box_annotator.annotate(
        scene=frame.copy(), detections=detections)
    annotated_frame = label_annotator.annotate(
        scene=annotated_frame, detections=detections, labels=labels)
    return annotated_frame

sv.process_video(
    source_path="<SOURCE_VIDEO_PATH>",
    target_path="<TARGET_VIDEO_PATH>",
    callback=callback
)
```

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

### Initialize YOLO Model and Load Video

Source: https://supervision.roboflow.com/latest/how_to/count_in_zone

Set up a YOLOv8 model and load a video using supervision's VideoInfo for metadata extraction. A shared color palette ensures consistent zone coloring.

```python
import numpy as np
import supervision as sv
import cv2

from ultralytics import YOLO

model = YOLO("yolov8s.pt")

VIDEO = str(VideoAssets.VEHICLES_2)

colors = sv.ColorPalette.default()
video_info = sv.VideoInfo.from_video_path(VIDEO)
```

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

### Install Inference

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Install the inference package for model inference capabilities.

```bash
pip install inference
```

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

### __init__

Source: https://supervision.roboflow.com/latest/detection/annotators

Initializes the annotator with visual configuration settings for text, colors, and positioning.

```APIDOC
## __init__(color, color_lookup, text_color, text_scale, text_thickness, text_padding, text_position, text_offset, border_radius, smart_position, max_line_length)

### Description
Initializes the annotator instance with specific visual parameters for rendering labels and backgrounds.

### Parameters
- **color** (Color | ColorPalette | str) - Optional - The color or color palette to use for annotating the text background. Default: ColorPalette.DEFAULT
- **color_lookup** (ColorLookup) - Optional - Strategy for mapping colors to annotations (INDEX, CLASS, TRACK). Default: ColorLookup.CLASS
- **text_color** (Color | ColorPalette | str) - Optional - The color or color palette to use for the text. Default: Color.WHITE
- **text_scale** (float) - Optional - Font scale for the text. Default: 0.5
- **text_thickness** (int) - Optional - Thickness of the text characters. Default: 1
- **text_padding** (int) - Optional - Padding around the text within its background box. Default: 10
- **text_position** (Position) - Optional - Position of the text relative to the detection. Default: Position.TOP_LEFT
- **text_offset** (tuple[int, int]) - Optional - A tuple of 2D coordinates (x, y) to offset the text position from the anchor point, in pixels. Default: (0, 0)
- **border_radius** (int) - Optional - The radius to apply round edges. Default: 0
- **smart_position** (bool) - Optional - Spread out the labels to avoid overlapping. Default: False
- **max_line_length** (int | None) - Optional - Maximum number of characters per line before wrapping the text. Default: None
```

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

### Install YOLOv8

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Install the ultralytics package to use YOLOv8 models with Supervision.

```bash
pip install ultralytics
```

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

### Initialize and use HaloAnnotator

Source: https://supervision.roboflow.com/latest/detection/annotators

Demonstrates how to instantiate the HaloAnnotator and apply it to an image with detections.

```pycon
>>> import numpy as np
>>> import supervision as sv
>>> image = np.zeros((100, 100, 3), dtype=np.uint8)
>>> detections = sv.Detections(
...     xyxy=np.array([[20, 20, 80, 80]]),
...     class_id=np.array([0])
... )
>>> halo_annotator = sv.HaloAnnotator()
>>> annotated_frame = halo_annotator.annotate(
...     scene=image.copy(),
...     detections=detections
... )
```

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

### Initialize and use CropAnnotator

Source: https://supervision.roboflow.com/latest/detection/annotators

Demonstrates how to instantiate the CropAnnotator and apply it to an image with detections.

```pycon
>>> import numpy as np
>>> import supervision as sv
>>> image = np.zeros((100, 100, 3), dtype=np.uint8)
>>> detections = sv.Detections(
...     xyxy=np.array([[20, 20, 80, 80]]),
...     class_id=np.array([0])
... )
>>> crop_annotator = sv.CropAnnotator()
>>> annotated_frame = crop_annotator.annotate(
...     scene=image.copy(),
...     detections=detections
... )
```

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

### Install Supervision and Inference Dependencies

Source: https://supervision.roboflow.com/latest/notebooks/object-tracking

Installs the necessary GPU-enabled inference and supervision packages.

```bash
!pip install -q inference-gpu "supervision"
```

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

### Install Roboflow Package

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Install the roboflow pip package to interact with Roboflow services.

```bash
!pip install -q roboflow

```

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

### HaloAnnotator.__init__

Source: https://supervision.roboflow.com/latest/detection/annotators

Initializes the HaloAnnotator with configuration for color, opacity, kernel size, and color lookup strategy.

```APIDOC
### Constructor: HaloAnnotator(color, opacity, kernel_size, color_lookup)

#### Parameters
- **color** (Color | ColorPalette | str) - Optional - The color or color palette to use for annotating detections. Defaults to ColorPalette.DEFAULT.
- **opacity** (float) - Optional - Opacity of the overlay mask. Must be between 0 and 1. Defaults to 0.8.
- **kernel_size** (int) - Optional - The size of the average pooling kernel used for creating the halo. Defaults to 40.
- **color_lookup** (ColorLookup) - Optional - Strategy for mapping colors to annotations (INDEX, CLASS, TRACK). Defaults to ColorLookup.CLASS.
```

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

### Install Roboflow Python Package

Source: https://supervision.roboflow.com/latest/how_to/process_datasets

Install the Roboflow library to enable dataset downloading.

```bash
pip install roboflow
```

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

### Start and Join Inference Pipeline

Source: https://supervision.roboflow.com/latest/notebooks/serialise-detections-to-json

Starts the video processing pipeline and waits for it to complete.

```python
pipeline.start()
pipeline.join()
```

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

### HaloAnnotator.__init__

Source: https://supervision.roboflow.com/latest/detection/annotators

Initializes the HaloAnnotator with configuration for color, opacity, kernel size, and color lookup strategy.

```APIDOC
## HaloAnnotator.__init__

### Description
Initializes a new instance of the HaloAnnotator class.

### Parameters
- **color** (Color | ColorPalette | str) - Optional - The color or color palette to use for annotating detections. Default: ColorPalette.DEFAULT
- **opacity** (float) - Optional - Opacity of the overlay mask. Must be between 0 and 1. Default: 0.8
- **kernel_size** (int) - Optional - The size of the average pooling kernel used for creating the halo. Default: 40
- **color_lookup** (ColorLookup) - Optional - Strategy for mapping colors to annotations. Options are INDEX, CLASS, TRACK. Default: ColorLookup.CLASS
```

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

### Install Ultralytics Package

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Installs the ultralytics package quietly. This is required for using YOLOv8 models.

```python
!pip install -q ultralytics

```

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

### Initialize and use DotAnnotator

Source: https://supervision.roboflow.com/latest/detection/annotators

Demonstrates how to instantiate the DotAnnotator and apply it to an image using detection coordinates.

```pycon
>>> import numpy as np
>>> import supervision as sv
>>> image = np.zeros((100, 100, 3), dtype=np.uint8)
>>> detections = sv.Detections(
...     xyxy=np.array([[20, 20, 80, 80]]),
...     class_id=np.array([0])
... )
>>> dot_annotator = sv.DotAnnotator()
>>> annotated_frame = dot_annotator.annotate(
...     scene=image.copy(),
...     detections=detections
... )
```

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

### TraceAnnotator Usage Example

Source: https://supervision.roboflow.com/latest/detection/annotators

Example demonstrating how to integrate TraceAnnotator into a video processing pipeline with ByteTrack.

```python
import supervision as sv
from ultralytics import YOLO

model = YOLO('yolov8x.pt')
trace_annotator = sv.TraceAnnotator()

video_info = sv.VideoInfo.from_video_path(video_path='...')
frames_generator = sv.get_video_frames_generator(source_path='...')
tracker = sv.ByteTrack()

with sv.VideoSink(target_path='...', video_info=video_info) as sink:
   for frame in frames_generator:
       result = model(frame)[0]
       detections = sv.Detections.from_ultralytics(result)
       detections = tracker.update_with_detections(detections)
       annotated_frame = trace_annotator.annotate(
           scene=frame.copy(),
           detections=detections)
       sink.write_frame(frame=annotated_frame)
```

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

### Download Sample Video Assets

Source: https://supervision.roboflow.com/latest/how_to/track_objects

Downloads the 'PEOPLE_WALKING' video asset for use in tutorials. This is a prerequisite for running the subsequent code examples.

```python
from supervision.assets import download_assets, VideoAssets

download_assets(VideoAssets.PEOPLE_WALKING)
```

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

### PixelateAnnotator Usage Example

Source: https://supervision.roboflow.com/latest/detection/annotators

A simple example demonstrating how to instantiate and use the PixelateAnnotator to annotate an image.

```python
import supervision as sv

image = ...
detections = sv.Detections(...)

pixelate_annotator = sv.PixelateAnnotator()
annotated_frame = pixelate_annotator.annotate(
    scene=image.copy(),
    detections=detections
)
```

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

### Install YOLO-NAS Dependencies

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Installs the super-gradients package and upgrades urllib3. These are required for using YOLO-NAS models.

```python
!pip install -q super-gradients
!pip install --upgrade urllib3

```

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

### Configure Video Source and Model Parameters

Source: https://supervision.roboflow.com/latest/notebooks/serialise-detections-to-csv

Sets up the source video path, confidence threshold, IOU threshold, output file name, and the inference model to be used.

```python
SOURCE_VIDEO_PATH = download_assets(VideoAssets.PEOPLE_WALKING)
CONFIDENCE_THRESHOLD = 0.3
IOU_THRESHOLD = 0.7
FILE_NAME = "detections.csv"
INFERENCE_MODEL = "yolov8n-640"

```

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

### Initialize and Use ByteTrack Tracker with YOLO

Source: https://supervision.roboflow.com/latest/trackers

This example demonstrates how to initialize a YOLO model and the ByteTrack tracker. It defines a callback function to process video frames, updating detections with the tracker and annotating the frame with tracker IDs. Finally, it uses `sv.process_video` to apply this callback to a video.

```python
import supervision as sv
from ultralytics import YOLO

model = YOLO("<MODEL_PATH>")
tracker = sv.ByteTrack()

box_annotator = sv.BoxAnnotator()
label_annotator = sv.LabelAnnotator()

def callback(frame: np.ndarray, index: int) -> np.ndarray:
    results = model(frame)[0]
    detections = sv.Detections.from_ultralytics(results)
    detections = tracker.update_with_detections(detections)

    labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id]

    annotated_frame = box_annotator.annotate(
        scene=frame.copy(), detections=detections)
    annotated_frame = label_annotator.annotate(
        scene=annotated_frame, detections=detections, labels=labels)
    return annotated_frame

sv.process_video(
    source_path="<SOURCE_VIDEO_PATH>",
    target_path="<TARGET_VIDEO_PATH>",
    callback=callback
)


```

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

### Install Ultralytics YOLO

Source: https://supervision.roboflow.com/latest/how_to/benchmark_a_model

Install the Ultralytics library, specifically version 8.3.40, for using YOLO models.

```bash
pip install "ultralytics<=8.3.40"

```

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

### Install Inference Package

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Installs the inference package quietly. This is needed for using the inference library's models.

```python
!pip install -q inference

```

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

### __init__(color: Color | ColorPalette | str, thickness: int, color_lookup: ColorLookup)

Source: https://supervision.roboflow.com/latest/detection/annotators

Initializes the annotator with specified visual settings for detection rendering.

```APIDOC
## __init__

### Description
Initializes the annotator instance with configurable color and thickness settings for drawing detections.

### Parameters
- **color** (Color | ColorPalette | str) - Optional - The color or color palette to use for annotating detections. Defaults to ColorPalette.DEFAULT.
- **thickness** (int) - Optional - Thickness of the circle line. Defaults to 2.
- **color_lookup** (ColorLookup) - Optional - Strategy for mapping colors to detections. Defaults to ColorLookup.CLASS.
```

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

### Install Supervision with Mamba

Source: https://supervision.roboflow.com/latest

Install the supervision library using Mamba from the conda-forge channel. Mamba is a faster alternative to Conda.

```bash
mamba install -c conda-forge supervision
```

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

### Initialize and use BoxAnnotator

Source: https://supervision.roboflow.com/latest/detection/annotators

Demonstrates how to instantiate the BoxAnnotator and apply it to an image with provided detections.

```pycon
>>> import numpy as np
>>> import supervision as sv
>>> image = np.zeros((100, 100, 3), dtype=np.uint8)
>>> detections = sv.Detections(
...     xyxy=np.array([[20, 20, 80, 80]]),
...     class_id=np.array([0])
... )
>>> box_annotator = sv.BoxAnnotator()
>>> annotated_frame = box_annotator.annotate(
...     scene=image.copy(),
...     detections=detections
... )
```

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

### Create Videos Directory

Source: https://supervision.roboflow.com/latest/notebooks/quickstart

Create a directory named 'videos' in the user's home directory to store video files. This is a prerequisite for video processing examples.

```bash
!mkdir {HOME}/videos
```

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

### Install Supervision with Conda

Source: https://supervision.roboflow.com/latest

Install the supervision library using Conda from the conda-forge channel. This is suitable for users managing environments with Conda.

```bash
conda install -c conda-forge supervision
```

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

### Install Inference GPU Package

Source: https://supervision.roboflow.com/latest/notebooks/zero-shot-object-detection-with-yolo-world

Installs the 'inference-gpu' package with YOLO-World support. This package is required for running zero-shot object detection models.

```bash
!pip install -q inference-gpu[yolo-world]==0.9.12rc1

```

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

### Using Gemini 2.5 with google-generativeai Client

Source: https://supervision.roboflow.com/latest/detection/core

This example shows how to construct a multi-part content request for the Gemini API, placing the image first followed by the text prompt. This ordering is recommended for better results.

```python
from google.generativeai import types

response = model.generate_content(
    contents=[
        types.Part.from_image(image_bytes),
        "Carefully examine this image and detect ALL visible objects, including "
        "small, distant, or partially visible ones.",
    ],
    generation_config=generation_config,
    safety_settings=safety_settings,
)

```

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

### Initialize ImageSink Context Manager

Source: https://supervision.roboflow.com/latest/utils/image

Demonstrates using ImageSink as a context manager to save multiple images to a temporary directory.

```python
>>> import numpy as np
>>> import supervision as sv
>>> import tempfile
>>> import os
>>> with tempfile.TemporaryDirectory() as tmpdir:
...     image = np.zeros((100, 100, 3), dtype=np.uint8)
...     with sv.ImageSink(target_dir_path=tmpdir, overwrite=True) as sink:
...         sink.save_image(image=image)
...         sink.save_image(image=image)
...     files = sorted(os.listdir(tmpdir))
...     len(files)
2
```

```python
def __init__(
    self,
    target_dir_path: str,
    overwrite: bool = False,
    image_name_pattern: str = "image_{:05d}.png",
):
    """
    Initialize context manager for saving images to directory.

    Args:
        target_dir_path: Target directory path where images will be
            saved.
        overwrite: Whether to overwrite existing directory.
            Defaults to `False`.
        image_name_pattern: File name pattern for saved images.
            Defaults to `"image_{:05d}.png"`.

    Examples:
        ```pycon
        >>> import numpy as np
        >>> import supervision as sv
        >>> import tempfile
        >>> import os
        >>> with tempfile.TemporaryDirectory() as tmpdir:
        ...     image = np.zeros((100, 100, 3), dtype=np.uint8)
        ...     with sv.ImageSink(target_dir_path=tmpdir, overwrite=True) as sink:
        ...         sink.save_image(image=image)
        ...         sink.save_image(image=image)
        ...     files = sorted(os.listdir(tmpdir))
        ...     len(files)
        2

        ```
    """
    self.target_dir_path = target_dir_path
    self.overwrite = overwrite
    self.image_name_pattern = image_name_pattern
    self.image_count = 0
```
Tokens:
Raw