Skip to content

Core

Warning

Dataset API is still fluid and may change. If you use Dataset API in your project until further notice, freeze the supervision version in your requirements.txt or setup.py.

DetectionDataset

Bases: BaseDataset

Dataclass containing information about object detection dataset.

Attributes:

Name Type Description
classes List[str]

List containing dataset class names.
images Dict[str, ndarray]

Dictionary mapping image name to image.
annotations Dict[str, Detections]

Dictionary mapping image name to annotations.
Source code in supervision/dataset/core.py 
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
@dataclass
class DetectionDataset(BaseDataset):
    """
    Dataclass containing information about object detection dataset.

    Attributes:
        classes (List[str]): List containing dataset class names.
        images (Dict[str, np.ndarray]): Dictionary mapping image name to image.
        annotations (Dict[str, Detections]): Dictionary mapping image name to annotations.
    """

    classes: List[str]
    images: Dict[str, np.ndarray]
    annotations: Dict[str, Detections]

    def __len__(self) -> int:
        """
        Return the number of images in the dataset.

        Returns:
            int: The number of images.
        """
        return len(self.images)

    def __iter__(self) -> Iterator[Tuple[str, np.ndarray, Detections]]:
        """
        Iterate over the images and annotations in the dataset.

        Yields:
            Iterator[Tuple[str, np.ndarray, Detections]]: An iterator that yields tuples containing the image name,
                                                          the image data, and its corresponding annotation.
        """
        for image_name, image in self.images.items():
            yield image_name, image, self.annotations.get(image_name, None)

    def split(
        self, split_ratio=0.8, random_state=None, shuffle: bool = True
    ) -> Tuple[DetectionDataset, DetectionDataset]:
        """
        Splits the dataset into two parts (training and testing) using the provided split_ratio.

        Args:
            split_ratio (float, optional): The ratio of the training set to the entire dataset. Default is 0.8.
            random_state (int, optional): The seed for the random number generator. This is used for reproducibility. Default is None.
            shuffle (bool, optional): Whether to shuffle the data before splitting. Default is True.

        Returns:
            Tuple[DetectionDataset, DetectionDataset]: A tuple containing the training and testing datasets.

        Example:
            ```python
            >>> import supervision as sv

            >>> dataset = sv.DetectionDataset(...)
            >>> train_dataset, test_dataset = dataset.split(split_ratio=0.7, random_state=42, shuffle=True)
            >>> len(train_dataset), len(test_dataset)
            (700, 300)
            ```
        """

        image_names = list(self.images.keys())
        train_names, test_names = train_test_split(
            data=image_names,
            train_ratio=split_ratio,
            random_state=random_state,
            shuffle=shuffle,
        )

        train_dataset = DetectionDataset(
            classes=self.classes,
            images={name: self.images[name] for name in train_names},
            annotations={name: self.annotations[name] for name in train_names},
        )
        test_dataset = DetectionDataset(
            classes=self.classes,
            images={name: self.images[name] for name in test_names},
            annotations={name: self.annotations[name] for name in test_names},
        )
        return train_dataset, test_dataset

    def as_pascal_voc(
        self,
        images_directory_path: Optional[str] = None,
        annotations_directory_path: Optional[str] = None,
        min_image_area_percentage: float = 0.0,
        max_image_area_percentage: float = 1.0,
        approximation_percentage: float = 0.0,
    ) -> None:
        """
        Exports the dataset to PASCAL VOC format. This method saves the images and their corresponding annotations in
        PASCAL VOC format, which consists of XML files. The method allows filtering the detections based on their area
        percentage.

        Args:
            images_directory_path (Optional[str]): The path to the directory where the images should be saved.
                If not provided, images will not be saved.
            annotations_directory_path (Optional[str]): The path to the directory where the annotations in
                PASCAL VOC format should be saved. If not provided, annotations will not be saved.
            min_image_area_percentage (float): The minimum percentage of detection area relative to
                the image area for a detection to be included.
            max_image_area_percentage (float): The maximum percentage of detection area relative to
                the image area for a detection to be included.
            approximation_percentage (float): The percentage of polygon points to be removed from the input polygon, in the range [0, 1).
        """
        if images_directory_path:
            images_path = Path(images_directory_path)
            images_path.mkdir(parents=True, exist_ok=True)

        if annotations_directory_path:
            annotations_path = Path(annotations_directory_path)
            annotations_path.mkdir(parents=True, exist_ok=True)

        for image_name, image in self.images.items():
            detections = self.annotations[image_name]

            if images_directory_path:
                cv2.imwrite(str(images_path / image_name), image)

            if annotations_directory_path:
                annotation_name = Path(image_name).stem
                pascal_voc_xml = detections_to_pascal_voc(
                    detections=detections,
                    classes=self.classes,
                    filename=image_name,
                    image_shape=image.shape,
                    min_image_area_percentage=min_image_area_percentage,
                    max_image_area_percentage=max_image_area_percentage,
                    approximation_percentage=approximation_percentage,
                )

                with open(annotations_path / f"{annotation_name}.xml", "w") as f:
                    f.write(pascal_voc_xml)

    @classmethod
    def from_pascal_voc(
        cls, images_directory_path: str, annotations_directory_path: str
    ) -> DetectionDataset:
        """
        Creates a Dataset instance from PASCAL VOC formatted data.

        Args:
            images_directory_path (str): The path to the directory containing the images.
            annotations_directory_path (str): The path to the directory containing the PASCAL VOC XML annotations.

        Returns:
            DetectionDataset: A DetectionDataset instance containing the loaded images and annotations.

        Example:
            ```python
            >>> import roboflow
            >>> from roboflow import Roboflow
            >>> import supervision as sv

            >>> roboflow.login()

            >>> rf = Roboflow()

            >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
            >>> dataset = project.version(PROJECT_VERSION).download("voc")

            >>> train_dataset = sv.Dataset.from_yolo(
            ...     images_directory_path=f"{dataset.location}/train/images",
            ...     annotations_directory_path=f"{dataset.location}/train/labels"
            ... )

            >>> dataset.classes
            ['dog', 'person']
            ```
        """
        image_paths = list_files_with_extensions(
            directory=images_directory_path, extensions=["jpg", "jpeg", "png"]
        )
        annotation_paths = list_files_with_extensions(
            directory=annotations_directory_path, extensions=["xml"]
        )

        raw_annotations: List[Tuple[str, Detections, List[str]]] = [
            load_pascal_voc_annotations(annotation_path=str(annotation_path))
            for annotation_path in annotation_paths
        ]

        classes = []
        for annotation in raw_annotations:
            classes.extend(annotation[2])
        classes = list(set(classes))

        for annotation in raw_annotations:
            class_id = [classes.index(class_name) for class_name in annotation[2]]
            annotation[1].class_id = np.array(class_id)

        images = {
            image_path.name: cv2.imread(str(image_path)) for image_path in image_paths
        }

        annotations = {
            image_name: detections for image_name, detections, _ in raw_annotations
        }
        return DetectionDataset(classes=classes, images=images, annotations=annotations)

    @classmethod
    def from_yolo(
        cls,
        images_directory_path: str,
        annotations_directory_path: str,
        data_yaml_path: str,
        force_masks: bool = False,
    ) -> DetectionDataset:
        """
        Creates a Dataset instance from YOLO formatted data.

        Args:
            images_directory_path (str): The path to the directory containing the images.
            annotations_directory_path (str): The path to the directory containing the YOLO annotation files.
            data_yaml_path (str): The path to the data YAML file containing class information.
            force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present.

        Returns:
            DetectionDataset: A DetectionDataset instance containing the loaded images and annotations.

        Example:
            ```python
            >>> import roboflow
            >>> from roboflow import Roboflow
            >>> import supervision as sv

            >>> roboflow.login()

            >>> rf = Roboflow()

            >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
            >>> dataset = project.version(PROJECT_VERSION).download("yolov5")

            >>> train_dataset = sv.Dataset.from_yolo(
            ...     images_directory_path=f"{dataset.location}/train/images",
            ...     annotations_directory_path=f"{dataset.location}/train/labels",
            ...     data_yaml_path=f"{dataset.location}/data.yaml"
            ... )

            >>> dataset.classes
            ['dog', 'person']
            ```
        """
        classes, images, annotations = load_yolo_annotations(
            images_directory_path=images_directory_path,
            annotations_directory_path=annotations_directory_path,
            data_yaml_path=data_yaml_path,
            force_masks=force_masks,
        )
        return DetectionDataset(classes=classes, images=images, annotations=annotations)

    def as_yolo(
        self,
        images_directory_path: Optional[str] = None,
        annotations_directory_path: Optional[str] = None,
        data_yaml_path: Optional[str] = None,
        min_image_area_percentage: float = 0.0,
        max_image_area_percentage: float = 1.0,
        approximation_percentage: float = 0.0,
    ) -> None:
        """
        Exports the dataset to YOLO (You Only Look Once) format. This method saves the images and their corresponding
        annotations in YOLO format, which is a simple text file that describes an object in the image. It also allows
        for the optional saving of a data.yaml file, used in YOLOv5, that contains metadata about the dataset.

        The method allows filtering the detections based on their area percentage and offers an option for polygon approximation.

        Args:
            images_directory_path (Optional[str]): The path to the directory where the images should be saved.
                If not provided, images will not be saved.
            annotations_directory_path (Optional[str]): The path to the directory where the annotations in
                YOLO format should be saved. If not provided, annotations will not be saved.
            data_yaml_path (Optional[str]): The path where the data.yaml file should be saved.
                If not provided, the file will not be saved.
            min_image_area_percentage (float): The minimum percentage of detection area relative to
                the image area for a detection to be included.
            max_image_area_percentage (float): The maximum percentage of detection area relative to
                the image area for a detection to be included.
            approximation_percentage (float): The percentage of polygon points to be removed from the input polygon,
                in the range [0, 1). This is useful for simplifying the annotations.
        """
        if images_directory_path is not None:
            save_dataset_images(
                images_directory_path=images_directory_path, images=self.images
            )
        if annotations_directory_path is not None:
            save_yolo_annotations(
                annotations_directory_path=annotations_directory_path,
                images=self.images,
                annotations=self.annotations,
                min_image_area_percentage=min_image_area_percentage,
                max_image_area_percentage=max_image_area_percentage,
                approximation_percentage=approximation_percentage,
            )
        if data_yaml_path is not None:
            save_data_yaml(data_yaml_path=data_yaml_path, classes=self.classes)

__iter__()

Iterate over the images and annotations in the dataset.

Yields:

Type Description
str

Iterator[Tuple[str, np.ndarray, Detections]]: An iterator that yields tuples containing the image name, the image data, and its corresponding annotation.
Source code in supervision/dataset/core.py 
62
63
64
65
66
67
68
69
70
71
def __iter__(self) -> Iterator[Tuple[str, np.ndarray, Detections]]:
    """
    Iterate over the images and annotations in the dataset.

    Yields:
        Iterator[Tuple[str, np.ndarray, Detections]]: An iterator that yields tuples containing the image name,
                                                      the image data, and its corresponding annotation.
    """
    for image_name, image in self.images.items():
        yield image_name, image, self.annotations.get(image_name, None)

__len__()

Return the number of images in the dataset.

Returns:

Name Type Description
int int

The number of images.
Source code in supervision/dataset/core.py 
53
54
55
56
57
58
59
60
def __len__(self) -> int:
    """
    Return the number of images in the dataset.

    Returns:
        int: The number of images.
    """
    return len(self.images)

as_pascal_voc(images_directory_path=None, annotations_directory_path=None, min_image_area_percentage=0.0, max_image_area_percentage=1.0, approximation_percentage=0.0)

Exports the dataset to PASCAL VOC format. This method saves the images and their corresponding annotations in PASCAL VOC format, which consists of XML files. The method allows filtering the detections based on their area percentage.

Parameters:

Name Type Description Default
images_directory_path Optional[str]

The path to the directory where the images should be saved. If not provided, images will not be saved.

 None
annotations_directory_path Optional[str]

The path to the directory where the annotations in PASCAL VOC format should be saved. If not provided, annotations will not be saved.

 None
min_image_area_percentage float

The minimum percentage of detection area relative to the image area for a detection to be included.

 0.0
max_image_area_percentage float

The maximum percentage of detection area relative to the image area for a detection to be included.

 1.0
approximation_percentage float

The percentage of polygon points to be removed from the input polygon, in the range [0, 1).

 0.0
Source code in supervision/dataset/core.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
def as_pascal_voc(
    self,
    images_directory_path: Optional[str] = None,
    annotations_directory_path: Optional[str] = None,
    min_image_area_percentage: float = 0.0,
    max_image_area_percentage: float = 1.0,
    approximation_percentage: float = 0.0,
) -> None:
    """
    Exports the dataset to PASCAL VOC format. This method saves the images and their corresponding annotations in
    PASCAL VOC format, which consists of XML files. The method allows filtering the detections based on their area
    percentage.

    Args:
        images_directory_path (Optional[str]): The path to the directory where the images should be saved.
            If not provided, images will not be saved.
        annotations_directory_path (Optional[str]): The path to the directory where the annotations in
            PASCAL VOC format should be saved. If not provided, annotations will not be saved.
        min_image_area_percentage (float): The minimum percentage of detection area relative to
            the image area for a detection to be included.
        max_image_area_percentage (float): The maximum percentage of detection area relative to
            the image area for a detection to be included.
        approximation_percentage (float): The percentage of polygon points to be removed from the input polygon, in the range [0, 1).
    """
    if images_directory_path:
        images_path = Path(images_directory_path)
        images_path.mkdir(parents=True, exist_ok=True)

    if annotations_directory_path:
        annotations_path = Path(annotations_directory_path)
        annotations_path.mkdir(parents=True, exist_ok=True)

    for image_name, image in self.images.items():
        detections = self.annotations[image_name]

        if images_directory_path:
            cv2.imwrite(str(images_path / image_name), image)

        if annotations_directory_path:
            annotation_name = Path(image_name).stem
            pascal_voc_xml = detections_to_pascal_voc(
                detections=detections,
                classes=self.classes,
                filename=image_name,
                image_shape=image.shape,
                min_image_area_percentage=min_image_area_percentage,
                max_image_area_percentage=max_image_area_percentage,
                approximation_percentage=approximation_percentage,
            )

            with open(annotations_path / f"{annotation_name}.xml", "w") as f:
                f.write(pascal_voc_xml)

as_yolo(images_directory_path=None, annotations_directory_path=None, data_yaml_path=None, min_image_area_percentage=0.0, max_image_area_percentage=1.0, approximation_percentage=0.0)

Exports the dataset to YOLO (You Only Look Once) format. This method saves the images and their corresponding annotations in YOLO format, which is a simple text file that describes an object in the image. It also allows for the optional saving of a data.yaml file, used in YOLOv5, that contains metadata about the dataset.

The method allows filtering the detections based on their area percentage and offers an option for polygon approximation.

Parameters:

Name Type Description Default
images_directory_path Optional[str]

The path to the directory where the images should be saved. If not provided, images will not be saved.

 None
annotations_directory_path Optional[str]

The path to the directory where the annotations in YOLO format should be saved. If not provided, annotations will not be saved.

 None
data_yaml_path Optional[str]

The path where the data.yaml file should be saved. If not provided, the file will not be saved.

 None
min_image_area_percentage float

The minimum percentage of detection area relative to the image area for a detection to be included.

 0.0
max_image_area_percentage float

The maximum percentage of detection area relative to the image area for a detection to be included.

 1.0
approximation_percentage float

The percentage of polygon points to be removed from the input polygon, in the range [0, 1). This is useful for simplifying the annotations.

 0.0
Source code in supervision/dataset/core.py 
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
def as_yolo(
    self,
    images_directory_path: Optional[str] = None,
    annotations_directory_path: Optional[str] = None,
    data_yaml_path: Optional[str] = None,
    min_image_area_percentage: float = 0.0,
    max_image_area_percentage: float = 1.0,
    approximation_percentage: float = 0.0,
) -> None:
    """
    Exports the dataset to YOLO (You Only Look Once) format. This method saves the images and their corresponding
    annotations in YOLO format, which is a simple text file that describes an object in the image. It also allows
    for the optional saving of a data.yaml file, used in YOLOv5, that contains metadata about the dataset.

    The method allows filtering the detections based on their area percentage and offers an option for polygon approximation.

    Args:
        images_directory_path (Optional[str]): The path to the directory where the images should be saved.
            If not provided, images will not be saved.
        annotations_directory_path (Optional[str]): The path to the directory where the annotations in
            YOLO format should be saved. If not provided, annotations will not be saved.
        data_yaml_path (Optional[str]): The path where the data.yaml file should be saved.
            If not provided, the file will not be saved.
        min_image_area_percentage (float): The minimum percentage of detection area relative to
            the image area for a detection to be included.
        max_image_area_percentage (float): The maximum percentage of detection area relative to
            the image area for a detection to be included.
        approximation_percentage (float): The percentage of polygon points to be removed from the input polygon,
            in the range [0, 1). This is useful for simplifying the annotations.
    """
    if images_directory_path is not None:
        save_dataset_images(
            images_directory_path=images_directory_path, images=self.images
        )
    if annotations_directory_path is not None:
        save_yolo_annotations(
            annotations_directory_path=annotations_directory_path,
            images=self.images,
            annotations=self.annotations,
            min_image_area_percentage=min_image_area_percentage,
            max_image_area_percentage=max_image_area_percentage,
            approximation_percentage=approximation_percentage,
        )
    if data_yaml_path is not None:
        save_data_yaml(data_yaml_path=data_yaml_path, classes=self.classes)

from_pascal_voc(images_directory_path, annotations_directory_path) classmethod

Creates a Dataset instance from PASCAL VOC formatted data.

Parameters:

Name Type Description Default
images_directory_path str

The path to the directory containing the images.

 required
annotations_directory_path str

The path to the directory containing the PASCAL VOC XML annotations.

 required

Returns:

Name Type Description
DetectionDataset DetectionDataset

A DetectionDataset instance containing the loaded images and annotations.
Example 
>>> import roboflow
>>> from roboflow import Roboflow
>>> import supervision as sv

>>> roboflow.login()

>>> rf = Roboflow()

>>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
>>> dataset = project.version(PROJECT_VERSION).download("voc")

>>> train_dataset = sv.Dataset.from_yolo(
...     images_directory_path=f"{dataset.location}/train/images",
...     annotations_directory_path=f"{dataset.location}/train/labels"
... )

>>> dataset.classes
['dog', 'person']
Source code in supervision/dataset/core.py 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
@classmethod
def from_pascal_voc(
    cls, images_directory_path: str, annotations_directory_path: str
) -> DetectionDataset:
    """
    Creates a Dataset instance from PASCAL VOC formatted data.

    Args:
        images_directory_path (str): The path to the directory containing the images.
        annotations_directory_path (str): The path to the directory containing the PASCAL VOC XML annotations.

    Returns:
        DetectionDataset: A DetectionDataset instance containing the loaded images and annotations.

    Example:
        ```python
        >>> import roboflow
        >>> from roboflow import Roboflow
        >>> import supervision as sv

        >>> roboflow.login()

        >>> rf = Roboflow()

        >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
        >>> dataset = project.version(PROJECT_VERSION).download("voc")

        >>> train_dataset = sv.Dataset.from_yolo(
        ...     images_directory_path=f"{dataset.location}/train/images",
        ...     annotations_directory_path=f"{dataset.location}/train/labels"
        ... )

        >>> dataset.classes
        ['dog', 'person']
        ```
    """
    image_paths = list_files_with_extensions(
        directory=images_directory_path, extensions=["jpg", "jpeg", "png"]
    )
    annotation_paths = list_files_with_extensions(
        directory=annotations_directory_path, extensions=["xml"]
    )

    raw_annotations: List[Tuple[str, Detections, List[str]]] = [
        load_pascal_voc_annotations(annotation_path=str(annotation_path))
        for annotation_path in annotation_paths
    ]

    classes = []
    for annotation in raw_annotations:
        classes.extend(annotation[2])
    classes = list(set(classes))

    for annotation in raw_annotations:
        class_id = [classes.index(class_name) for class_name in annotation[2]]
        annotation[1].class_id = np.array(class_id)

    images = {
        image_path.name: cv2.imread(str(image_path)) for image_path in image_paths
    }

    annotations = {
        image_name: detections for image_name, detections, _ in raw_annotations
    }
    return DetectionDataset(classes=classes, images=images, annotations=annotations)

from_yolo(images_directory_path, annotations_directory_path, data_yaml_path, force_masks=False) classmethod

Creates a Dataset instance from YOLO formatted data.

Parameters:

Name Type Description Default
images_directory_path str

The path to the directory containing the images.

 required
annotations_directory_path str

The path to the directory containing the YOLO annotation files.

 required
data_yaml_path str

The path to the data YAML file containing class information.

 required
force_masks bool

If True, forces masks to be loaded for all annotations, regardless of whether they are present.

 False

Returns:

Name Type Description
DetectionDataset DetectionDataset

A DetectionDataset instance containing the loaded images and annotations.
Example 
>>> import roboflow
>>> from roboflow import Roboflow
>>> import supervision as sv

>>> roboflow.login()

>>> rf = Roboflow()

>>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
>>> dataset = project.version(PROJECT_VERSION).download("yolov5")

>>> train_dataset = sv.Dataset.from_yolo(
...     images_directory_path=f"{dataset.location}/train/images",
...     annotations_directory_path=f"{dataset.location}/train/labels",
...     data_yaml_path=f"{dataset.location}/data.yaml"
... )

>>> dataset.classes
['dog', 'person']
Source code in supervision/dataset/core.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
@classmethod
def from_yolo(
    cls,
    images_directory_path: str,
    annotations_directory_path: str,
    data_yaml_path: str,
    force_masks: bool = False,
) -> DetectionDataset:
    """
    Creates a Dataset instance from YOLO formatted data.

    Args:
        images_directory_path (str): The path to the directory containing the images.
        annotations_directory_path (str): The path to the directory containing the YOLO annotation files.
        data_yaml_path (str): The path to the data YAML file containing class information.
        force_masks (bool, optional): If True, forces masks to be loaded for all annotations, regardless of whether they are present.

    Returns:
        DetectionDataset: A DetectionDataset instance containing the loaded images and annotations.

    Example:
        ```python
        >>> import roboflow
        >>> from roboflow import Roboflow
        >>> import supervision as sv

        >>> roboflow.login()

        >>> rf = Roboflow()

        >>> project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
        >>> dataset = project.version(PROJECT_VERSION).download("yolov5")

        >>> train_dataset = sv.Dataset.from_yolo(
        ...     images_directory_path=f"{dataset.location}/train/images",
        ...     annotations_directory_path=f"{dataset.location}/train/labels",
        ...     data_yaml_path=f"{dataset.location}/data.yaml"
        ... )

        >>> dataset.classes
        ['dog', 'person']
        ```
    """
    classes, images, annotations = load_yolo_annotations(
        images_directory_path=images_directory_path,
        annotations_directory_path=annotations_directory_path,
        data_yaml_path=data_yaml_path,
        force_masks=force_masks,
    )
    return DetectionDataset(classes=classes, images=images, annotations=annotations)

split(split_ratio=0.8, random_state=None, shuffle=True)

Splits the dataset into two parts (training and testing) using the provided split_ratio.

Parameters:

Name Type Description Default
split_ratio float

The ratio of the training set to the entire dataset. Default is 0.8.

 0.8
random_state int

The seed for the random number generator. This is used for reproducibility. Default is None.

 None
shuffle bool

Whether to shuffle the data before splitting. Default is True.

 True

Returns:

Type Description
Tuple[DetectionDataset, DetectionDataset]

Tuple[DetectionDataset, DetectionDataset]: A tuple containing the training and testing datasets.
Example 
>>> import supervision as sv

>>> dataset = sv.DetectionDataset(...)
>>> train_dataset, test_dataset = dataset.split(split_ratio=0.7, random_state=42, shuffle=True)
>>> len(train_dataset), len(test_dataset)
(700, 300)
Source code in supervision/dataset/core.py 
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
def split(
    self, split_ratio=0.8, random_state=None, shuffle: bool = True
) -> Tuple[DetectionDataset, DetectionDataset]:
    """
    Splits the dataset into two parts (training and testing) using the provided split_ratio.

    Args:
        split_ratio (float, optional): The ratio of the training set to the entire dataset. Default is 0.8.
        random_state (int, optional): The seed for the random number generator. This is used for reproducibility. Default is None.
        shuffle (bool, optional): Whether to shuffle the data before splitting. Default is True.

    Returns:
        Tuple[DetectionDataset, DetectionDataset]: A tuple containing the training and testing datasets.

    Example:
        ```python
        >>> import supervision as sv

        >>> dataset = sv.DetectionDataset(...)
        >>> train_dataset, test_dataset = dataset.split(split_ratio=0.7, random_state=42, shuffle=True)
        >>> len(train_dataset), len(test_dataset)
        (700, 300)
        ```
    """

    image_names = list(self.images.keys())
    train_names, test_names = train_test_split(
        data=image_names,
        train_ratio=split_ratio,
        random_state=random_state,
        shuffle=shuffle,
    )

    train_dataset = DetectionDataset(
        classes=self.classes,
        images={name: self.images[name] for name in train_names},
        annotations={name: self.annotations[name] for name in train_names},
    )
    test_dataset = DetectionDataset(
        classes=self.classes,
        images={name: self.images[name] for name in test_names},
        annotations={name: self.annotations[name] for name in test_names},
    )
    return train_dataset, test_dataset