# Exporting FiftyOne Datasets
FiftyOne provides native support for exporting datasets to disk in a
variety of [common formats](#supported-export-formats), and it can be
easily extended to export datasets in
[custom formats](#custom-dataset-exporter).
#### NOTE
Did you know? You can export media and/or labels from within the FiftyOne
App by installing the
[@voxel51/io](https://github.com/voxel51/fiftyone-plugins/tree/main/plugins/io)
plugin!
## Basic recipe
The interface for exporting a FiftyOne [`Dataset`](../api/fiftyone.core.dataset.md#fiftyone.core.dataset.Dataset) is conveniently exposed via
the Python library and the CLI. You can easily export entire datasets as well
as arbitrary subsets of your datasets that you have identified by constructing
a [`DatasetView`](../api/fiftyone.core.view.md#fiftyone.core.view.DatasetView) into any format of your choice via the basic recipe below.
Python
CLI
You can export a [`Dataset`](../api/fiftyone.core.dataset.md#fiftyone.core.dataset.Dataset) or [`DatasetView`](../api/fiftyone.core.view.md#fiftyone.core.view.DatasetView) via their
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
method:
```python
import fiftyone as fo
# The Dataset or DatasetView containing the samples you wish to export
dataset_or_view = fo.load_dataset(...)
# The directory to which to write the exported dataset
export_dir = "/path/for/export"
# The name of the sample field containing the label that you wish to export
# Used when exporting labeled datasets (e.g., classification or detection)
label_field = "ground_truth" # for example
# The type of dataset to export
# Any subclass of `fiftyone.types.Dataset` is supported
dataset_type = fo.types.COCODetectionDataset # for example
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=dataset_type,
label_field=label_field,
)
```
Note the `label_field` argument in the above example, which specifies the
particular label field that you wish to export. This is necessary if your
FiftyOne dataset contains multiple label fields.
The [`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
method also provides additional parameters that you can use to configure
the export. For example, you can use the `data_path` and `labels_path`
parameters to independently customize the location of the exported media
and labels, including labels-only exports:
```python
# Export **only** labels in the `ground_truth` field in COCO format
# with absolute image filepaths in the labels
dataset_or_view.export(
dataset_type=fo.types.COCODetectionDataset,
labels_path="/path/for/export.json",
label_field="ground_truth",
abs_paths=True,
)
```
Or you can use the `export_media` parameter to configure whether to copy,
move, symlink, or omit the media files from the export:
```python
# Export the labels in the `ground_truth` field in COCO format, and
# move (rather than copy) the source media to the output directory
dataset_or_view.export(
export_dir="/path/for/export",
dataset_type=fo.types.COCODetectionDataset,
label_field="ground_truth",
export_media="move",
)
```
In general, you can pass any parameter for the [`DatasetExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.DatasetExporter) of the
format you’re writing to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export).
You can export a FiftyOne dataset
[via the CLI](../cli/index.md#cli-fiftyone-datasets-export):
```shell
# The name of the FiftyOne dataset to export
NAME="your-dataset"
# The directory to which to write the exported dataset
EXPORT_DIR=/path/for/export
# The name of the sample field containing the label that you wish to export
# Used when exporting labeled datasets (e.g., classification or detection)
LABEL_FIELD=ground_truth # for example
# The type of dataset to export
# Any subclass of `fiftyone.types.Dataset` is supported
TYPE=fiftyone.types.COCODetectionDataset # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type $TYPE \
--label-field $LABEL_FIELD
```
Note the `LABEL_FIELD` argument in the above example, which specifies the
particular label field that you wish to export. This is necessary your
FiftyOne dataset contains multiple label fields.
You can use the [kwargs option](../cli/index.md#cli-fiftyone-datasets-export) to
provide additional parameters to configure the export. For example, you can
use the `data_path` and `labels_path` parameters to independently
customize the location of the exported media and labels, including
labels-only exports:
```shell
# Export **only** labels in the `ground_truth` field in COCO format
# with absolute image filepaths in the labels
fiftyone datasets export $NAME \
--type fiftyone.types.COCODetectionDataset \
--label-field ground_truth \
--kwargs \
labels_path=/path/for/labels.json \
abs_paths=True
```
Or you can use the `export_media` parameter to configure whether to copy,
move, symlink, or omit the media files from the export:
```shell
# Export the labels in the `ground_truth` field in COCO format, and
# move (rather than copy) the source media to the output directory
fiftyone datasets export $NAME \
--export-dir /path/for/export \
--type fiftyone.types.COCODetectionDataset \
--label-field ground_truth \
--kwargs export_media=move
```
In general, you can pass any parameter for the [`DatasetExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.DatasetExporter) of the
format you’re writing via the
[kwargs option](../cli/index.md#cli-fiftyone-datasets-export).
## Label type coercion
For your convenience, the
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) method
will automatically coerce the data to match the requested export types in a
variety of common cases listed below.
### Single labels to lists
Many export formats expect label list types
([`Classifications`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Classifications), [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections), [`Polylines`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Polylines), or [`Keypoints`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Keypoints)). If you provide
a label field to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) that
refers to a single label type ([`Classification`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Classification), [`Detection`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detection), [`Polyline`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Polyline), or
[`Keypoint`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Keypoint)), then the labels will be automatically upgraded to single-label
lists to match the export type’s expectations.
```python
import fiftyone as fo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart")
patches = dataset.to_patches("ground_truth")
# The `ground_truth` field has type `Detection`, but COCO format expects
# `Detections`, so the labels are automatically coerced to single-label lists
patches.export(
export_dir="/tmp/quickstart/detections",
dataset_type=fo.types.COCODetectionDataset,
label_field="ground_truth",
)
```
### Classifications as detections
When exporting in labeled image dataset formats that expect [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections)
labels, if you provide a label field to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) that has
type [`Classification`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Classification), the classification labels will be automatically upgraded
to detections that span the entire images.
```python
import fiftyone as fo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart").limit(5).clone()
for idx, sample in enumerate(dataset):
sample["attribute"] = fo.Classification(label=str(idx))
sample.save()
# Exports the `attribute` classifications as detections that span entire images
dataset.export(
export_dir="/tmp/quickstart/attributes",
dataset_type=fo.types.COCODetectionDataset,
label_field="attribute",
)
```
### Object patches
When exporting in either an unlabeled image or image classification format, if
a spatial label field ([`Detection`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detection), [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections), [`Polyline`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Polyline), or [`Polylines`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Polylines))
is provided to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export), the
[object patches](app.md#app-object-patches) of the provided samples will be
exported.
```python
import fiftyone as fo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart")
# No label field is provided; only images are exported
dataset.export(
export_dir="/tmp/quickstart/images",
dataset_type=fo.types.ImageDirectory,
)
# A detections field is provided, so the object patches are exported as a
# directory of images
dataset.export(
export_dir="/tmp/quickstart/patches",
dataset_type=fo.types.ImageDirectory,
label_field="ground_truth",
)
# A detections field is provided, so the object patches are exported as an
# image classification directory tree
dataset.export(
export_dir="/tmp/quickstart/objects",
dataset_type=fo.types.ImageClassificationDirectoryTree,
label_field="ground_truth",
)
```
You can also directly call
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) on
[patches views](using_views.md#object-patches-views) to export the specified object
patches along with their appropriately typed labels.
```python
# Continuing from above...
patches = dataset.to_patches("ground_truth")
# Export the object patches as a directory of images
patches.export(
export_dir="/tmp/quickstart/also-patches",
dataset_type=fo.types.ImageDirectory,
)
# Export the object patches as an image classification directory tree
patches.export(
export_dir="/tmp/quickstart/also-objects",
dataset_type=fo.types.ImageClassificationDirectoryTree,
)
```
### Video clips
When exporting in either an unlabeled video or video classification format, if
a [`TemporalDetection`](../api/fiftyone.core.labels.md#fiftyone.core.labels.TemporalDetection) or [`TemporalDetections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.TemporalDetections) field is provided to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export), the
specified [video clips](app.md#app-video-clips) will be exported.
```python
import fiftyone as fo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart-video", max_samples=2)
# Add some temporal detections to the dataset
sample1 = dataset.first()
sample1["events"] = fo.TemporalDetections(
detections=[
fo.TemporalDetection(label="first", support=[31, 60]),
fo.TemporalDetection(label="second", support=[90, 120]),
]
)
sample1.save()
sample2 = dataset.last()
sample2["events"] = fo.TemporalDetections(
detections=[
fo.TemporalDetection(label="first", support=[16, 45]),
fo.TemporalDetection(label="second", support=[75, 104]),
]
)
sample2.save()
# A temporal detection field is provided, so the clips are exported as a
# directory of videos
dataset.export(
export_dir="/tmp/quickstart-video/clips",
dataset_type=fo.types.VideoDirectory,
label_field="events",
)
# A temporal detection field is provided, so the clips are exported as a
# video classification directory tree
dataset.export(
export_dir="/tmp/quickstart-video/video-classifications",
dataset_type=fo.types.VideoClassificationDirectoryTree,
label_field="events",
)
```
You can also directly call
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) on
[clip views](using_views.md#clip-views) to export the specified video clips along with
their appropriately typed labels.
```python
# Continuing from above...
clips = dataset.to_clips("events")
# Export the clips as a directory of videos
clips.export(
export_dir="/tmp/quickstart-video/also-clips",
dataset_type=fo.types.VideoDirectory,
)
# Export the clips as a video classification directory tree
clips.export(
export_dir="/tmp/quickstart-video/clip-classifications",
dataset_type=fo.types.VideoClassificationDirectoryTree,
)
# Export the clips along with their associated frame labels
clips.export(
export_dir="/tmp/quickstart-video/clip-frame-labels",
dataset_type=fo.types.FiftyOneVideoLabelsDataset,
frame_labels_field="detections",
)
```
## Class lists
Certain labeled image/video export formats such as
[COCO](#cocodetectiondataset-export) and
[YOLO](#yolov5dataset-export) store an explicit list of classes for the
label field being exported.
By convention, all exporters provided by FiftyOne should provide a `classes`
parameter that allows for manually specifying the classes list to use.
If no explicit class list is provided, the observed classes in the collection
being exported are used, which may be a subset of the classes in the parent
dataset when exporting a view.
#### NOTE
See [this section](using_datasets.md#storing-classes) for more information about
storing class lists on FiftyOne datasets.
```python
import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F
# Load 10 samples containing cats and dogs (among other objects)
dataset = foz.load_zoo_dataset(
"coco-2017",
split="validation",
classes=["cat", "dog"],
shuffle=True,
max_samples=10,
)
# Loading zoo datasets generally populates the `default_classes` attribute
print(len(dataset.default_classes)) # 91
# Create a view that only contains cats and dogs
view = dataset.filter_labels("ground_truth", F("label").is_in(["cat", "dog"]))
# By default, only the observed classes will be stored as COCO categories
view.export(
labels_path="/tmp/coco1.json",
dataset_type=fo.types.COCODetectionDataset,
)
# However, if desired, we can explicitly provide a classes list
view.export(
labels_path="/tmp/coco2.json",
dataset_type=fo.types.COCODetectionDataset,
classes=dataset.default_classes,
)
```
## Built-in formats
FiftyOne provides a variety of built-in exporters for common data formats.
Each data format is represented by a subclass of
[`fiftyone.types.Dataset`](../api/fiftyone.types.md#fiftyone.types.Dataset), which is used by the Python library and CLI to
refer to the corresponding dataset format when writing the dataset to disk.
## Image Directory
The [`fiftyone.types.ImageDirectory`](../api/fiftyone.types.md#fiftyone.types.ImageDirectory) type represents a directory of
images.
Datasets of this type are exported in the following format:
```text
/
..
...
```
#### NOTE
See [`ImageDirectoryExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.ImageDirectoryExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export the images in a FiftyOne dataset as a directory of images on
disk as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/images-dir"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir, dataset_type=fo.types.ImageDirectory
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/to/images-dir
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.ImageDirectory
```
## Video Directory
The [`fiftyone.types.VideoDirectory`](../api/fiftyone.types.md#fiftyone.types.VideoDirectory) type represents a directory of
videos.
Datasets of this type are exported in the following format:
```text
/
..
...
```
#### NOTE
See [`VideoDirectoryExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.VideoDirectoryExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export the videos in a FiftyOne dataset as a directory of videos on
disk as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/videos-dir"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir, dataset_type=fo.types.VideoDirectory
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/to/videos-dir
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.VideoDirectory
```
## Media Directory
The [`fiftyone.types.MediaDirectory`](../api/fiftyone.types.md#fiftyone.types.MediaDirectory) type represents a directory of
media files.
Datasets of this type are exported in the following format:
```text
/
..
...
```
#### NOTE
See [`MediaDirectoryExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.MediaDirectoryExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export the media in a FiftyOne dataset as a directory of media files on
disk as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/media-dir"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir, dataset_type=fo.types.MediaDirectory
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/to/media-dir
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.MediaDirectory
```
## Image Classification Dir Tree
The [`fiftyone.types.ImageClassificationDirectoryTree`](../api/fiftyone.types.md#fiftyone.types.ImageClassificationDirectoryTree) type represents a
directory tree whose subfolders define an image classification dataset.
Datasets of this type are exported in the following format:
```text
/
/
..
...
/
..
...
...
```
Unlabeled images are stored in a subdirectory named `_unlabeled`.
#### NOTE
See [`ImageClassificationDirectoryTreeExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.ImageClassificationDirectoryTreeExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as an image classification directory tree
stored on disk in the above format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/image-classification-dir-tree"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.ImageClassificationDirectoryTree,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/image-classification-dir-tree
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.ImageClassificationDirectoryTree
```
## Video Classification Dir Tree
The [`fiftyone.types.VideoClassificationDirectoryTree`](../api/fiftyone.types.md#fiftyone.types.VideoClassificationDirectoryTree) type represents a
directory tree whose subfolders define a video classification dataset.
Datasets of this type are exported in the following format:
```text
/
/
..
...
/
..
...
...
```
Unlabeled videos are stored in a subdirectory named `_unlabeled`.
#### NOTE
See [`VideoClassificationDirectoryTreeExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.VideoClassificationDirectoryTreeExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a video classification directory tree
stored on disk in the above format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/video-classification-dir-tree"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.VideoClassificationDirectoryTree,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/video-classification-dir-tree
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.VideoClassificationDirectoryTree
```
## FiftyOne Image Classification
The [`fiftyone.types.FiftyOneImageClassificationDataset`](../api/fiftyone.types.md#fiftyone.types.FiftyOneImageClassificationDataset) type represents
a labeled dataset consisting of images and their associated classification
label(s) stored in a simple JSON format.
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
In the simplest case, `labels.json` will be a JSON file in the following
format:
```text
{
"classes": [
"",
"",
...
],
"labels": {
"": ,
"": ,
...
}
}
```
If the `classes` field is included in the JSON, the `target` values are class
IDs that are mapped to class label strings via `classes[target]`. If no
`classes` are included, then the `target` values directly store the label
strings.
The target value in `labels` for unlabeled images is `None`.
If you wish to export classifications with associated confidences and/or
additional attributes, you can use the `include_confidence` and
`include_attributes` parameters to include this information in the export.
In this case, `labels.json` will have the following format:
```text
{
"classes": [
"",
"",
...
],
"labels": {
"": {
"label": ,
"confidence": ,
"attributes": {
: ,
...
}
},
"": {
"label": ,
"confidence": ,
"attributes": {
: ,
...
}
},
...
}
}
```
You can also export multilabel classification fields, in which case
`labels.json` will have the following format:
```text
{
"classes": [
"",
"",
...
],
"labels": {
"": [, , ...],
"": [, , ...],
...
}
}
```
where the target values in `labels` may be class strings, class IDs, or dicts
in the format described above defining class labels, confidences, and optional
attributes, depending on how you configured the export.
#### NOTE
See [`FiftyOneImageClassificationDatasetExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.FiftyOneImageClassificationDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as an image classification dataset stored on
disk in the above format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/image-classification-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.FiftyOneImageClassificationDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/image-classification-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageClassificationDataset
```
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
You can also perform labels-only exports in this format by providing the
`labels_path` parameter instead of `export_dir` to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a location to write (only) the labels.
#### NOTE
You can optionally include the `export_media=False` option to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
make it explicit that you only wish to export labels, although this will be
inferred if you do not provide an `export_dir` or `data_path`.
By default, the filenames of your images will be used as keys in the exported
labels. However, you can also provide the optional `rel_dir` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a prefix to strip from each image path to generate a key for the image. This
argument allows for populating nested subdirectories that match the shape of
the input paths.
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels using the basename of each image as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneImageClassificationDataset,
labels_path=labels_path,
label_field=label_field,
)
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneImageClassificationDataset,
labels_path=labels_path,
label_field=label_field,
rel_dir="/common/images/dir",
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/labels.json
LABEL_FIELD=ground_truth # for example
# Export labels using the basename of each image as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageClassificationDataset \
--kwargs labels_path=$LABELS_PATH
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageClassificationDataset \
--kwargs \
labels_path=$LABELS_PATH \
rel_dir=/common/images/dir
```
## TF Image Classification
The [`fiftyone.types.TFImageClassificationDataset`](../api/fiftyone.types.md#fiftyone.types.TFImageClassificationDataset) type represents a
labeled dataset consisting of images and their associated classification labels
stored as
[TFRecords](https://www.tensorflow.org/tutorials/load_data/tfrecord).
Datasets of this type are exported in the following format:
```text
/
tf.records-?????-of-?????
```
where the features of the (possibly sharded) TFRecords are stored in the
following format:
```python
{
# Image dimensions
"height": tf.io.FixedLenFeature([], tf.int64),
"width": tf.io.FixedLenFeature([], tf.int64),
"depth": tf.io.FixedLenFeature([], tf.int64),
# Image filename
"filename": tf.io.FixedLenFeature([], tf.int64),
# The image extension
"format": tf.io.FixedLenFeature([], tf.string),
# Encoded image bytes
"image_bytes": tf.io.FixedLenFeature([], tf.string),
# Class label string
"label": tf.io.FixedLenFeature([], tf.string, default_value=""),
}
```
For unlabeled samples, the TFRecords do not contain `label` features.
#### NOTE
See [`TFImageClassificationDatasetExporter`](../api/fiftyone.utils.tf.md#fiftyone.utils.tf.TFImageClassificationDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a directory of TFRecords in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/tf-image-classification-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.TFImageClassificationDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/tf-image-classification-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.TFImageClassificationDataset
```
#### NOTE
You can provide the `tf_records_path` argument instead of `export_dir` in
the examples above to directly specify the path to the TFRecord(s) to
write. See
[`TFImageClassificationDatasetExporter`](../api/fiftyone.utils.tf.md#fiftyone.utils.tf.TFImageClassificationDatasetExporter)
for details.
## COCO
The [`fiftyone.types.COCODetectionDataset`](../api/fiftyone.types.md#fiftyone.types.COCODetectionDataset) type represents a labeled
dataset consisting of images and their associated object detections saved in
[COCO Object Detection Format](https://cocodataset.org/#format-data).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
where `labels.json` is a JSON file in the following format:
```text
{
"info": {
"year": "",
"version": "",
"description": "Exported from FiftyOne",
"contributor": "",
"url": "https://voxel51.com/fiftyone",
"date_created": "2020-06-19T09:48:27"
},
"licenses": [],
"categories": [
{
"id": 1,
"name": "cat",
"supercategory": "animal"
},
...
],
"images": [
{
"id": 1,
"license": null,
"file_name": ".",
"height": 480,
"width": 640,
"date_captured": null
},
...
],
"annotations": [
{
"id": 1,
"image_id": 1,
"category_id": 1,
"bbox": [260, 177, 231, 199],
"segmentation": [...],
"score": 0.95,
"area": 45969,
"iscrowd": 0
},
...
]
}
```
See [this page](https://cocodataset.org/#format-data) for a full
specification of the `segmentation` field, which will only be included if you
export [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections) with instance masks populated or [`Polylines`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Polylines).
For unlabeled datasets, `labels.json` does not contain an `annotations` field.
The `file_name` attribute of the labels file encodes the location of the
corresponding images, which can be any of the following:
- The filename of an image in the `data/` folder
- A relative path like `path/to/filename.ext` specifying the relative path to
the image in a nested subfolder of `data/`
- An absolute path to an image, which may or may not be in the `data/` folder
#### NOTE
See [`COCODetectionDatasetExporter`](../api/fiftyone.utils.coco.md#fiftyone.utils.coco.COCODetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a COCO detection dataset in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/image-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.COCODetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/coco-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.COCODetectionDataset
```
#### NOTE
You can pass the optional `classes` or `categories` parameters to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list/category IDs to use in the exported
labels. Otherwise, the strategy outlined in
[this section](#export-class-lists) will be used to populate the class
list.
You can also perform labels-only exports of COCO-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/coco-labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.COCODetectionDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/coco-labels.json
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.COCODetectionDataset \
--kwargs labels_path=$LABELS_PATH
```
## VOC
The [`fiftyone.types.VOCDetectionDataset`](../api/fiftyone.types.md#fiftyone.types.VOCDetectionDataset) type represents a labeled
dataset consisting of images and their associated object detections saved in
[VOC format](http://host.robots.ox.ac.uk/pascal/VOC).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels/
.xml
.xml
...
```
where the labels XML files are in the following format:
```xml
image.ext/path/to/dataset-dir/data/image.ext6404803
...
```
Samples with no values for certain attributes (like `pose` in the above
example) are left empty.
Unlabeled images have no corresponding file in `labels/`.
#### NOTE
See [`VOCDetectionDatasetExporter`](../api/fiftyone.utils.voc.md#fiftyone.utils.voc.VOCDetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a VOC detection dataset in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/voc-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.VOCDetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/voc-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.VOCDetectionDataset
```
You can also perform labels-only exports of VOC-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/voc-labels"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.VOCDetectionDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/voc-labels
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.VOCDetectionDataset \
--kwargs labels_path=$LABELS_PATH
```
## KITTI
The [`fiftyone.types.KITTIDetectionDataset`](../api/fiftyone.types.md#fiftyone.types.KITTIDetectionDataset) type represents a labeled
dataset consisting of images and their associated object detections saved in
[KITTI format](http://www.cvlibs.net/datasets/kitti/eval_object.php).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels/
.txt
.txt
...
```
where the labels TXT files are space-delimited files where each row corresponds
to an object and the 15 (and optional 16th score) columns have the following
meanings:
| # of columns | Name | Description | Default |
|--------------------|------------|------------------------------------------------------------------------------------------------------------------------------------------------|-----------|
| 1 | type | The object label | |
| 1 | truncated | A float in `[0, 1]`, where 0 is non-truncated and 1 is fully truncated. Here, truncation refers to the object leaving image boundaries | 0 |
| 1 | occluded | An int in `(0, 1, 2, 3)` indicating occlusion state, where:- 0 = fully visible- 1 = partly occluded- 2 = largely occluded- 3 = unknown | 0 |
| 1 | alpha | Observation angle of the object, in `[-pi, pi]` | 0 |
| 4 | bbox | 2D bounding box of object in the image in pixels, in the format `[xtl, ytl, xbr, ybr]` | |
| 1 | dimensions | 3D object dimensions, in meters, in the format `[height, width, length]` | 0 |
| 1 | location | 3D object location `(x, y, z)` in camera coordinates (in meters) | 0 |
| 1 | rotation_y | Rotation around the y-axis in camera coordinates, in `[-pi, pi]` | 0 |
| 1 | score | `(optional)` A float confidence for the detection | |
The `default` column above indicates the default value that will be used when
writing datasets in this type whose samples do not contain the necessary
field(s).
Unlabeled images have no corresponding file in `labels/`.
#### NOTE
See [`KITTIDetectionDatasetExporter`](../api/fiftyone.utils.kitti.md#fiftyone.utils.kitti.KITTIDetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a KITTI detection dataset in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/kitti-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.KITTIDetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/kitti-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.KITTIDetectionDataset
```
You can also perform labels-only exports of KITTI-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/kitti-labels"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.KITTIDetectionDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/kitti-labels
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.KITTIDetectionDataset \
--kwargs labels_path=$LABELS_PATH
```
## YOLOv4
The [`fiftyone.types.YOLOv4Dataset`](../api/fiftyone.types.md#fiftyone.types.YOLOv4Dataset) type represents a labeled dataset
consisting of images and their associated object detections saved in
[YOLOv4 format](https://github.com/AlexeyAB/darknet).
Datasets of this type are exported in the following format:
```text
/
obj.names
images.txt
data/
..txt
..txt
...
```
where `obj.names` contains the object class labels:
```text
...
```
and `images.txt` contains the list of images in `data/`:
```text
data/.
data/.
...
```
and the TXT files in `data/` are space-delimited files where each row
corresponds to an object in the image of the same name, in one of the following
formats:
```text
# Detections
# Instance segmentations or polygons
...
```
where `` is the zero-based integer index of the object class label from
`obj.names`, all coordinates are expressed as relative values in
`[0, 1] x [0, 1]`, and `` is an optional confidence in `[0, 1]`,
which will be included only if you pass the optional `include_confidence=True`
flag to the export.
Unlabeled images have no corresponding TXT file in `data/`.
#### NOTE
By default, only the bounding boxes of [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections) fields are exported.
However, you can choose to export instance segmentation masks as polygons
by passing the optional `use_masks=True` argument to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export):
```python
# Export instance segmentation masks as polygons
dataset.export(
...
dataset_type=fo.types.YOLOv4Dataset,
use_masks=True,
tolerance=2, # optional tolerance when converting masks to polygons
)
```
See [`YOLOv4DatasetExporter`](../api/fiftyone.utils.yolo.md#fiftyone.utils.yolo.YOLOv4DatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a YOLOv4 dataset in the above format as
follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/yolov4-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.YOLOv4Dataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/yolov4-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.YOLOv4Dataset
```
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
You can also perform labels-only exports of YOLO-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/yolo-labels"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.YOLOv4Dataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/yolo-labels
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.YOLOv4Dataset \
--kwargs labels_path=$LABELS_PATH
```
## YOLOv5
The [`fiftyone.types.YOLOv5Dataset`](../api/fiftyone.types.md#fiftyone.types.YOLOv5Dataset) type represents a labeled dataset
consisting of images and their associated object detections saved in
[YOLOv5 format](https://github.com/ultralytics/yolov5).
Datasets of this type are exported in the following format:
```text
/
dataset.yaml
images/
train/
..
...
val/
..
...
labels/
train/
.txt
.txt
...
val/
.txt
.txt
...
```
where `dataset.yaml` contains the following information:
```text
path: # optional
train: ./images/train/
val: ./images/val/
names:
0: list
1: of
2: classes
...
```
See [this page](https://docs.ultralytics.com/datasets/detect) for a full
description of the possible format of `dataset.yaml`. In particular, the
dataset may contain one or more splits with arbitrary names, as the specific
split being imported or exported is specified by the `split` argument to
[`fiftyone.utils.yolo.YOLOv5DatasetExporter`](../api/fiftyone.utils.yolo.md#fiftyone.utils.yolo.YOLOv5DatasetExporter). Also, `dataset.yaml` can be
located outside of `` as long as the optional `path` is provided.
The TXT files in `labels/` are space-delimited files where each row corresponds
to an object in the image of the same name, in one of the following formats:
```text
# Detections
# Instance segmentations or polygons
...
```
where `` is the zero-based integer index of the object class label from
`names`, all coordinates are expressed as relative values in `[0, 1] x [0, 1]`,
and `` is an optional confidence in `[0, 1]`, which will be
included only if you pass the optional `include_confidence=True` flag to the
export.
Unlabeled images have no corresponding TXT file in `labels/`. The label file
path for each image is obtained by replacing `images/` with `labels/` in the
respective image path.
#### NOTE
By default, only the bounding boxes of [`Detections`](../api/fiftyone.core.labels.md#fiftyone.core.labels.Detections) fields are exported.
However, you can choose to export instance segmentation masks as polygons
by passing the optional `use_masks=True` argument to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export):
```python
# Export instance segmentation masks as polygons
dataset.export(
...
dataset_type=fo.types.YOLOv5Dataset,
use_masks=True,
tolerance=2, # optional tolerance when converting masks to polygons
)
```
See [`YOLOv5DatasetExporter`](../api/fiftyone.utils.yolo.md#fiftyone.utils.yolo.YOLOv5DatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a YOLOv5 dataset in the above format as
follows:
```python
import fiftyone as fo
export_dir = "/path/for/yolov5-dataset"
label_field = "ground_truth" # for example
# The splits to export
splits = ["train", "val"]
# All splits must use the same classes list
classes = ["list", "of", "classes"]
# The dataset or view to export
# We assume the dataset uses sample tags to encode the splits to export
dataset_or_view = fo.load_dataset(...)
# Export the splits
for split in splits:
split_view = dataset_or_view.match_tags(split)
split_view.export(
export_dir=export_dir,
dataset_type=fo.types.YOLOv5Dataset,
label_field=label_field,
split=split,
classes=classes,
)
```
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
You can also perform labels-only exports of YOLO-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
```python
import fiftyone as fo
labels_path = "/path/for/yolo-labels"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.YOLOv5Dataset,
labels_path=labels_path,
label_field=label_field,
)
```
## FiftyOne Object Detection
The [`fiftyone.types.FiftyOneImageDetectionDataset`](../api/fiftyone.types.md#fiftyone.types.FiftyOneImageDetectionDataset) type represents a
labeled dataset consisting of images and their associated object detections
stored in a simple JSON format.
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
where `labels.json` is a JSON file in the following format:
```text
{
"classes": [
,
,
...
],
"labels": {
: [
{
"label": ,
"bounding_box": [
, , ,
],
"confidence": ,
"attributes": {
: ,
...
}
},
...
],
: [
...
],
...
}
}
```
and where the bounding box coordinates are expressed as relative values in
`[0, 1] x [0, 1]`.
If the `classes` field is included in the JSON, the `target` values are class
IDs that are mapped to class label strings via `classes[target]`. If no
`classes` are included, then the `target` values directly store the label
strings.
The target value in `labels` for unlabeled images is `None`.
By default, confidences and any additional dynamic attributes of your
detections will be automatically included in the export. However, you can
provide the optional `include_confidence` and `include_attributes` parameters
to customize this behavior.
#### NOTE
See [`FiftyOneImageDetectionDatasetExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.FiftyOneImageDetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as an image detection dataset in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/image-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.FiftyOneImageDetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/image-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageDetectionDataset
```
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
You can also perform labels-only exports in this format by providing the
`labels_path` parameter instead of `export_dir` to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a location to write (only) the labels.
#### NOTE
You can optionally include the `export_media=False` option to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
make it explicit that you only wish to export labels, although this will be
inferred if you do not provide an `export_dir` or `data_path`.
By default, the filenames of your images will be used as keys in the exported
labels. However, you can also provide the optional `rel_dir` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a prefix to strip from each image path to generate a key for the image. This
argument allows for populating nested subdirectories that match the shape of
the input paths.
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels using the basename of each image as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneImageDetectionDataset,
labels_path=labels_path,
label_field=label_field,
)
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneImageDetectionDataset,
labels_path=labels_path,
label_field=label_field,
rel_dir="/common/images/dir",
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/labels.json
LABEL_FIELD=ground_truth # for example
# Export labels using the basename of each image as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageDetectionDataset \
--kwargs labels_path=$LABELS_PATH
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneImageDetectionDataset \
--kwargs \
labels_path=$LABELS_PATH \
rel_dir=/common/images/dir
```
## FiftyOne Temporal Detection
The [`fiftyone.types.FiftyOneTemporalDetectionDataset`](../api/fiftyone.types.md#fiftyone.types.FiftyOneTemporalDetectionDataset) type represents a
labeled dataset consisting of videos and their associated temporal detections
stored in a simple JSON format.
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
where `labels.json` is a JSON file in the following format:
```text
{
"classes": [
"",
"",
...
],
"labels": {
"": [
{
"label": ,
"support": [, ],
"confidence": ,
"attributes": {
: ,
...
}
},
{
"label": ,
"support": [, ],
"confidence": ,
"attributes": {
: ,
...
}
},
...
],
"": [
{
"label": ,
"timestamps": [, ],
"confidence": ,
"attributes": {
: ,
...
}
},
{
"label": ,
"timestamps": [, ],
"confidence": ,
"attributes": {
: ,
...
}
},
],
...
}
}
```
By default, the `support` keys will be populated with the `[first, last]` frame
numbers of the detections, but you can pass the `use_timestamps=True` key
during export to instead populate the `timestamps` keys with the
`[start, stop]` timestamps of the detections, in seconds.
If the `classes` field is included in the JSON, the `target` values are class
IDs that are mapped to class label strings via `classes[target]`. If no
`classes` are included, then the `target` values directly store the label
strings.
The target value in `labels` for unlabeled videos is `None`.
By default, confidences and any additional dynamic attributes of your
detections will be automatically included in the export. However, you can
provide the optional `include_confidence` and `include_attributes` parameters
to customize this behavior.
#### NOTE
See [`FiftyOneTemporalDetectionDatasetExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.FiftyOneTemporalDetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a temporal detection dataset stored on
disk in the above format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/temporal-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.FiftyOneTemporalDetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/temporal-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneTemporalDetectionDataset
```
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
You can also perform labels-only exports in this format by providing the
`labels_path` parameter instead of `export_dir` to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a location to write (only) the labels.
#### NOTE
You can optionally include the `export_media=False` option to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
make it explicit that you only wish to export labels, although this will be
inferred if you do not provide an `export_dir` or `data_path`.
By default, the filenames of your images will be used as keys in the exported
labels. However, you can also provide the optional `rel_dir` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to specify
a prefix to strip from each image path to generate a key for the image. This
argument allows for populating nested subdirectories that match the shape of
the input paths.
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels using the basename of each image as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneTemporalDetectionDataset,
labels_path=labels_path,
label_field=label_field,
)
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
dataset_or_view.export(
dataset_type=fo.types.FiftyOneTemporalDetectionDataset,
labels_path=labels_path,
label_field=label_field,
rel_dir="/common/images/dir",
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/labels.json
LABEL_FIELD=ground_truth # for example
# Export labels using the basename of each image as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneTemporalDetectionDataset \
--kwargs labels_path=$LABELS_PATH
# Export labels using the relative path of each image with respect to
# the given `rel_dir` as keys
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.FiftyOneTemporalDetectionDataset \
--kwargs \
labels_path=$LABELS_PATH \
rel_dir=/common/images/dir
```
## TF Object Detection
The [`fiftyone.types.TFObjectDetectionDataset`](../api/fiftyone.types.md#fiftyone.types.TFObjectDetectionDataset) type represents a labeled
dataset consisting of images and their associated object detections stored as
[TFRecords](https://www.tensorflow.org/tutorials/load_data/tfrecord) in
[TF Object Detection API format](https://github.com/tensorflow/models/blob/master/research/object_detection).
Datasets of this type are exported in the following format:
```text
/
tf.records-?????-of-?????
```
where the features of the (possibly sharded) TFRecords are stored in the
following format:
```python
{
# Image dimensions
"image/height": tf.io.FixedLenFeature([], tf.int64),
"image/width": tf.io.FixedLenFeature([], tf.int64),
# Image filename is used for both of these when writing
"image/filename": tf.io.FixedLenFeature([], tf.string),
"image/source_id": tf.io.FixedLenFeature([], tf.string),
# Encoded image bytes
"image/encoded": tf.io.FixedLenFeature([], tf.string),
# Image format, either `jpeg` or `png`
"image/format": tf.io.FixedLenFeature([], tf.string),
# Normalized bounding box coordinates in `[0, 1]`
"image/object/bbox/xmin": tf.io.FixedLenSequenceFeature(
[], tf.float32, allow_missing=True
),
"image/object/bbox/xmax": tf.io.FixedLenSequenceFeature(
[], tf.float32, allow_missing=True
),
"image/object/bbox/ymin": tf.io.FixedLenSequenceFeature(
[], tf.float32, allow_missing=True
),
"image/object/bbox/ymax": tf.io.FixedLenSequenceFeature(
[], tf.float32, allow_missing=True
),
# Class label string
"image/object/class/text": tf.io.FixedLenSequenceFeature(
[], tf.string, allow_missing=True
),
# Integer class ID
"image/object/class/label": tf.io.FixedLenSequenceFeature(
[], tf.int64, allow_missing=True
),
}
```
The TFRecords for unlabeled samples do not contain `image/object/*` features.
#### NOTE
See [`TFObjectDetectionDatasetExporter`](../api/fiftyone.utils.tf.md#fiftyone.utils.tf.TFObjectDetectionDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a directory of TFRecords in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/tf-object-detection-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.TFObjectDetectionDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/tf-object-detection-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.TFObjectDetectionDataset
```
#### NOTE
You can provide the `tf_records_path` argument instead of `export_dir` in
the examples above to directly specify the path to the TFRecord(s) to
write. See
[`TFObjectDetectionDatasetExporter`](../api/fiftyone.utils.tf.md#fiftyone.utils.tf.TFObjectDetectionDatasetExporter)
for details.
#### NOTE
You can pass the optional `classes` parameter to
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export) to
explicitly define the class list to use in the exported labels. Otherwise,
the strategy outlined in [this section](#export-class-lists) will be
used to populate the class list.
## Image Segmentation Directory
The [`fiftyone.types.ImageSegmentationDirectory`](../api/fiftyone.types.md#fiftyone.types.ImageSegmentationDirectory) type represents a
labeled dataset consisting of images and their associated semantic
segmentations stored as images on disk.
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels/
..
...
```
where `labels/` contains the semantic segmentations stored as images.
By default, the masks will be stored as PNG images, but you can customize this
by passing the optional `mask_format` parameter. The masks will be stored as 8
bit images if they contain at most 256 classes, otherwise 16 bits will be used.
Unlabeled images have no corresponding file in `labels/`.
#### NOTE
See [`ImageSegmentationDirectoryExporter`](../api/fiftyone.utils.data.exporters.md#fiftyone.utils.data.exporters.ImageSegmentationDirectoryExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as an image segmentation dataset in the above
format as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/image-segmentation-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.ImageSegmentationDirectory,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/image-segmentation-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.ImageSegmentationDirectory
```
You can also export only the segmentation masks by providing the `labels_path`
parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/segmentation-masks"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.ImageSegmentationDirectory,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/segmentation-masks
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.ImageSegmentationDirectory \
--kwargs labels_path=$LABELS_PATH
```
## CVAT Image
The [`fiftyone.types.CVATImageDataset`](../api/fiftyone.types.md#fiftyone.types.CVATImageDataset) type represents a labeled dataset
consisting of images and their associated tags and object detections stored in
[CVAT image format](https://github.com/opencv/cvat).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.xml
```
where `labels.xml` is an XML file in the following format:
```xml
1.10task-name51annotationFalse2017-11-20 11:51:51.000000+00:002017-11-20 11:51:51.000000+00:00
...
00502017-11-20 11:51:51.000000+00:00
...
sedan
...
...
Honda
...
...
yellow
...
...
front_driver_side
...
...
...
...
```
Unlabeled images have no corresponding `image` tag in `labels.xml`.
The `name` field of the `` tags in the labels file encodes the location
of the corresponding images, which can be any of the following:
- The filename of an image in the `data/` folder
- A relative path like `path/to/filename.ext` specifying the relative path to
the image in a nested subfolder of `data/`
- An absolute path to an image, which may or may not be in the `data/` folder
#### NOTE
See [`CVATImageDatasetExporter`](../api/fiftyone.utils.cvat.md#fiftyone.utils.cvat.CVATImageDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a CVAT image dataset in the above format
as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/cvat-image-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.CVATImageDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/cvat-image-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.CVATImageDataset
```
You can also perform labels-only exports of CVAT-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/cvat-labels.xml"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.CVATImageDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/cvat-labels.xml
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.CVATImageDataset \
--kwargs labels_path=$LABELS_PATH
```
## CVAT Video
The [`fiftyone.types.CVATVideoDataset`](../api/fiftyone.types.md#fiftyone.types.CVATVideoDataset) type represents a labeled dataset
consisting of videos and their associated object detections stored in
[CVAT video format](https://github.com/opencv/cvat).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels/
.xml
.xml
...
```
where the labels XML files are stored in the following format:
```xml
1.1task-idtask-name51interpolationFalse2017-11-20 11:51:51.000000+00:002017-11-20 11:51:51.000000+00:00
...
00506404802017-11-20 11:51:51.000000+00:00
...
...
```
Unlabeled videos have no corresponding file in `labels/`.
#### NOTE
See [`CVATVideoDatasetExporter`](../api/fiftyone.utils.cvat.md#fiftyone.utils.cvat.CVATVideoDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a CVAT video dataset in the above format
as follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/cvat-video-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.CVATVideoDataset,
frame_labels_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/cvat-video-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.CVATVideoDataset \
--kwargs frame_labels_field=$LABEL_FIELD
```
You can also perform labels-only exports of CVAT-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/cvat-labels"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.CVATVideoDataset,
labels_path=labels_path,
frame_labels_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/cvat-labels
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.CVATVideoDataset \
--kwargs frames_labels_path=$LABELS_PATH
```
## BDD
The [`fiftyone.types.BDDDataset`](../api/fiftyone.types.md#fiftyone.types.BDDDataset) type represents a labeled dataset
consisting of images and their associated multitask predictions saved in
[Berkeley DeepDrive (BDD) format](http://bdd-data.berkeley.edu).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
where `labels.json` is a JSON file in the following format:
```text
[
{
"name": ".",
"attributes": {
"scene": "city street",
"timeofday": "daytime",
"weather": "overcast"
},
"labels": [
{
"id": 0,
"category": "traffic sign",
"manualAttributes": true,
"manualShape": true,
"attributes": {
"occluded": false,
"trafficLightColor": "none",
"truncated": false
},
"box2d": {
"x1": 1000.698742,
"x2": 1040.626872,
"y1": 281.992415,
"y2": 326.91156
},
"score": 0.95
},
...
{
"id": 34,
"category": "drivable area",
"manualAttributes": true,
"manualShape": true,
"attributes": {
"areaType": "direct"
},
"poly2d": [
{
"types": "LLLLCCC",
"closed": true,
"vertices": [
[241.143645, 697.923453],
[541.525255, 380.564983],
...
]
}
],
"score": 0.87
},
...
{
"id": 109356,
"category": "lane",
"attributes": {
"laneDirection": "parallel",
"laneStyle": "dashed",
"laneType": "single white"
},
"manualShape": true,
"manualAttributes": true,
"poly2d": [
{
"types": "LL",
"closed": false,
"vertices": [
[492.879546, 331.939543],
[0, 471.076658],
...
]
}
],
"score": 0.98
},
...
}
}
...
]
```
Unlabeled images have no corresponding entry in `labels.json`.
The `name` attribute of the labels file encodes the location of the
corresponding images, which can be any of the following:
- The filename of an image in the `data/` folder
- A relative path like `path/to/filename.ext` specifying the relative path to
the image in a nested subfolder of `data/`
- An absolute path to an image, which may or may not be in the `data/` folder
#### NOTE
See [`BDDDatasetExporter`](../api/fiftyone.utils.bdd.md#fiftyone.utils.bdd.BDDDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a BDD dataset in the above format as
follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/bdd-dataset"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.BDDDataset,
label_field=label_field,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/bdd-dataset
LABEL_FIELD=ground_truth # for example
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--label-field $LABEL_FIELD \
--type fiftyone.types.BDDDataset
```
You can also perform labels-only exports of BDD-formatted labels by providing
the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/bdd-labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.BDDDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/bdd-labels.json
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.BDDDataset \
--kwargs labels_path=$LABELS_PATH
```
## CSV
The [`fiftyone.types.CSVDataset`](../api/fiftyone.types.md#fiftyone.types.CSVDataset) type is a flexible CSV format that
represents slice(s) of field values of a dataset as columns of a CSV file.
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.csv
```
where `labels.csv` is a CSV file in the following format:
```text
field1,field2,field3,...
value1,value2,value3,...
value1,value2,value3,...
...
```
where the columns of interest are specified via the `fields` parameter, and may
contain any number of top-level or embedded fields such as strings, ints,
floats, booleans, or lists of such values.
List values are encoded as `"list,of,values"` with double quotes to escape the
commas. Missing field values are encoded as empty cells.
#### NOTE
See [`CSVDatasetExporter`](../api/fiftyone.utils.csv.md#fiftyone.utils.csv.CSVDatasetExporter) for
parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a CSV dataset in the above format as
follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/csv-dataset"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.CSVDataset,
fields=["list", "of", "fields"],
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/csv-dataset
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.CSVDataset \
--kwargs fields=list,of,fields
```
You can also directly export a CSV file of field values and absolute media
paths without exporting the actual media files by providing the `labels_path`
parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/labels.csv"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels with absolute media paths
dataset_or_view.export(
dataset_type=fo.types.CSVDataset,
labels_path=labels_path,
fields=["list", "of", "fields"],
abs_paths=True,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/labels.csv
# Export labels with absolute media paths
fiftyone datasets export $NAME \
--type fiftyone.types.CSVDataset \
--kwargs \
labels_path=$LABELS_PATH \
fields=list,of,fields \
abs_paths=True
```
## GeoJSON
The [`fiftyone.types.GeoJSONDataset`](../api/fiftyone.types.md#fiftyone.types.GeoJSONDataset) type represents a dataset consisting
of images or videos and their associated geolocation data and optional
properties stored in [GeoJSON format](https://en.wikipedia.org/wiki/GeoJSON).
Datasets of this type are exported in the following format:
```text
/
data/
..
...
labels.json
```
where `labels.json` is a GeoJSON file containing a `FeatureCollection` in
the following format:
```text
{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-73.99496451958454,
40.66338032487842
]
},
"properties": {
"filename": .,
...
}
},
{
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [
-73.80992143421788,
40.65611832778962
]
},
"properties": {
"filename": .,
...
}
},
...
]
}
```
where the `geometry` field may contain any valid GeoJSON geometry object, and
the `filename` property encodes the name of the corresponding media in the
`data/` folder. The `filename` property can also be an absolute path, which
may or may not be in the `data/` folder.
Samples with no location data will have a null `geometry` field.
The `properties` field of each feature can contain additional labels for
each sample.
#### NOTE
See [`GeoJSONDatasetExporter`](../api/fiftyone.utils.geojson.md#fiftyone.utils.geojson.GeoJSONDatasetExporter)
for parameters that can be passed to methods like
[`export()`](../api/fiftyone.core.collections.md#fiftyone.core.collections.SampleCollection.export)
to customize the export of datasets of this type.
You can export a FiftyOne dataset as a GeoJSON dataset in the above format as
follows:
Python
CLI
```python
import fiftyone as fo
export_dir = "/path/for/geojson-dataset"
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export the dataset
dataset_or_view.export(
export_dir=export_dir,
dataset_type=fo.types.GeoJSONDataset,
)
```
```shell
NAME=my-dataset
EXPORT_DIR=/path/for/geojson-dataset
# Export the dataset
fiftyone datasets export $NAME \
--export-dir $EXPORT_DIR \
--type fiftyone.types.GeoJSONDataset
```
You can also perform labels-only exports of GeoJSON-formatted labels by
providing the `labels_path` parameter instead of `export_dir`:
Python
CLI
```python
import fiftyone as fo
labels_path = "/path/for/geo-labels.json"
label_field = "ground_truth" # for example
# The dataset or view to export
dataset_or_view = fo.load_dataset(...)
# Export labels
dataset_or_view.export(
dataset_type=fo.types.GeoJSONDataset,
labels_path=labels_path,
label_field=label_field,
)
```
```shell
NAME=my-dataset
LABELS_PATH=/path/for/geo-labels.json
LABEL_FIELD=ground_truth # for example
# Export labels
fiftyone datasets export $NAME \
--label-field $LABEL_FIELD \
--type fiftyone.types.GeoJSONDataset \
--kwargs labels_path=$LABELS_PATH
```
## FiftyOne Dataset