### fiftyone quickstart

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Launches the FiftyOne quickstart environment. This can be used to quickly get started with FiftyOne, with options to include video datasets or launch as a remote session.

```APIDOC
## fiftyone quickstart

### Description
Launches the FiftyOne quickstart environment.

### Usage
```bash
fiftyone quickstart
fiftyone quickstart --video
fiftyone quickstart --remote
```

### Options
- `--video`: Launch the quickstart with a video dataset.
- `--remote`: Launch the quickstart as a remote session.
```

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

### Load Quickstart Dataset

Source: https://docs.voxel51.com/cheat_sheets/filtering_cheat_sheet.html

Loads the quickstart dataset for use in examples. Ensure FiftyOne is installed and configured.

```python
import fiftyone.zoo as foz
from fiftyone import ViewField as F

ds = foz.load_zoo_dataset("quickstart")
```

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

### Launch the FiftyOne Quickstart

Source: https://docs.voxel51.com/cli/index.html

Starts the FiftyOne quickstart, which is useful for a rapid introduction to FiftyOne's features. This command launches the App by default.

```bash
fiftyone quickstart

```

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

### Loading a Quickstart Dataset

Source: https://docs.voxel51.com/api/fiftyone.core.clips.html

Loads the 'quickstart' dataset from the FiftyOne Model Zoo for demonstration purposes. Requires fiftyone and fiftyone.zoo to be installed.

```python
import random

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

```

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

### Load Quickstart Dataset

Source: https://docs.voxel51.com/brain.html

Loads the 'quickstart' dataset from the FiftyOne Zoo. This is a common first step for many FiftyOne examples.

```python
import fiftyone as fo
import fiftyone.brain as fob
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")
```

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

### Load Quickstart Dataset

Source: https://docs.voxel51.com/api/fiftyone.core.collections.html

Loads the 'quickstart' dataset from the FiftyOne Model Zoo. This is a common starting point for examples and testing.

```python
import random

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")
```

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

### Load a quickstart dataset and launch app

Source: https://docs.voxel51.com/api/fiftyone.core.dataset.html

Loads the 'quickstart' dataset from the FiftyOne Model Zoo and launches the FiftyOne App for visualization. This is a common starting point for exploring FiftyOne.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")

session = fo.launch_app(dataset)
```

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

### Load Quickstart Image Dataset

Source: https://docs.voxel51.com/user_guide/using_datasets.html?_gl=1%2A1vonm1t%2A_gcl_au%2AMTI3OTEyMjEwMy4xNzI2MTQ5NDk3

Load the 'quickstart' dataset from the FiftyOne zoo to explore image data. This example demonstrates counting detections and labels.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")

print(dataset.count("ground_truth.detections"))  # 1232
print(dataset.count("predictions.detections"))  # 5620
print(dataset.count_values("ground_truth.detections.label"))
# {'dog': 15, 'airplane': 24, 'dining table': 15, 'hot dog': 5, ...}

session = fo.launch_app(dataset)
```

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

### Load and Explore Example 3D Dataset

Source: https://docs.voxel51.com/user_guide/using_datasets.html

Loads the 'quickstart-3d' dataset from the FiftyOne Zoo for exploration. This dataset is useful for getting started with 3D data visualization and analysis.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart-3d")

print(dataset.count_values("ground_truth.label"))
# {'bottle': 5, 'stairs': 5, 'keyboard': 5, 'car': 5, ...}

session = fo.launch_app(dataset)
```

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

### Load Dataset and Launch FiftyOne App

Source: https://docs.voxel51.com/integrations/albumentations.html

Load the quickstart dataset (or any other FiftyOne dataset) and launch the FiftyOne App to visualize it. This example selects only 5 samples and keeps only the ground truth labels for demonstration.

```python
import fiftyone as fo
import fiftyone.zoo as foz

## only take 5 samples for quick demonstration
dataset = foz.load_zoo_dataset("quickstart", max_samples=5)

# only keep the ground truth labels
dataset.select_fields("ground_truth").keep_fields()

session = fo.launch_app(dataset)

```

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

### Setup Example Data for Filtering

Source: https://docs.voxel51.com/cheat_sheets/filtering_cheat_sheet.html

Sets up an example dataset with tagged labels and specific label IDs for demonstrating filtering operations. Includes loading a dataset and tagging samples.

```python
from bson import ObjectId

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

ds = foz.load_zoo_dataset("quickstart")

# Tag a few random samples
ds.take(3).tag_labels("potential_mistake", label_fields="predictions")

# Grab a few label IDs
label_ids = [
    dataset.first().ground_truth.detections[0].id,
    dataset.last().predictions.detections[0].id,
]
ds.select_labels(ids=label_ids).tag_labels("error")

len_filter = F("label").strlen() < 3
id_filter = F("_id").is_in([ObjectId(_id) for _id in label_ids])
```

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

### Load Quickstart Dataset

Source: https://docs.voxel51.com/api/fiftyone.core.expressions.html

Loads the 'quickstart' dataset from FiftyOne Zoo. This is a common starting point for exploring FiftyOne's capabilities.

```python
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

```

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

### Load Quickstart Video Dataset with FiftyOne

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_video.html

Loads the 'quickstart-video' dataset and launches an interactive FiftyOne app session. Ensure ffmpeg is installed for video playback.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart-video")

session = fo.launch_app(dataset)
```

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

### Load Quickstart Dataset and SAM Model

Source: https://docs.voxel51.com/api/fiftyone.utils.sam.html

Loads the FiftyOne quickstart dataset and the segment-anything-vitb-torch model. This is a common setup for experimenting with SAM.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset(
    "quickstart", max_samples=5, shuffle=True, seed=51
)

model = foz.load_zoo_model("segment-anything-vitb-torch")
```

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

### Load Quickstart Groups Dataset in Python

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_groups.html

Loads the quickstart-groups dataset and launches the FiftyOne App for visualization. Requires FiftyOne to be installed.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart-groups")

session = fo.launch_app(dataset)
```

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

### Quickstart MolmoPoint Integration with FiftyOne

Source: https://docs.voxel51.com/plugins/plugins_ecosystem/molmo_point.html

This example demonstrates how to register the MolmoPoint model source, load a dataset, load the MolmoPoint model, set the pointing prompts, and apply the model to the dataset. It then launches a FiftyOne app session to visualize the results.

```python
import fiftyone as fo
import fiftyone.zoo as foz

# Register the model source
foz.register_zoo_model_source(
    "https://github.com/harpreetsahota204/molmo_point",
    overwrite=True
)

# Load a dataset
dataset = foz.load_zoo_dataset("quickstart")

# Load the model (weights are downloaded on first use)
model = foz.load_zoo_model("allenai/MolmoPoint-8B")

# Tell the model what to point at
model.prompt = ["person", "animal", "drink", "food", "vehicle"]

# Run on the dataset
dataset.apply_model(
    model,
    label_field="molmo_points",
    batch_size=4,
    num_workers=2,
)

session = fo.launch_app(dataset)

```

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

### Load and Visualize Quickstart 3D Dataset

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_3d.html

Use this Python code to load the 'quickstart-3d' dataset and launch an interactive FiftyOne app session for visualization. Ensure FiftyOne is installed.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart-3d")

session = fo.launch_app(dataset)
```

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

### Load a Dataset from the FiftyOne Zoo

Source: https://docs.voxel51.com/user_guide/using_datasets.html

Loads the 'quickstart' image dataset from the FiftyOne Zoo for immediate exploration. This example shows how to count specific fields and launch the FiftyOne App.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")

print(dataset.count("ground_truth.detections"))  # 1232
print(dataset.count("predictions.detections"))  # 5620
print(dataset.count_values("ground_truth.detections.label"))
# {'dog': 15, 'airplane': 24, 'dining table': 15, 'hot dog': 5, ...}

session = fo.launch_app(dataset)

```

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

### Setup Date Filtering Examples

Source: https://docs.voxel51.com/cheat_sheets/filtering_cheat_sheet.html

Imports necessary libraries and creates a dataset with sample data for date and time filtering operations. Includes predefined query dates and time deltas.

```python
from datetime import datetime, timedelta

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

filepaths = ["image%d.jpg" % i for i in range(5)]
dates = [
    datetime(2021, 8, 24, 1, 0, 0),
    datetime(2021, 8, 24, 2, 0, 0),
    datetime(2021, 8, 25, 3, 11, 12),
    datetime(2021, 9, 25, 4, 22, 23),
    datetime(2022, 9, 27, 5, 0, 0)
]

ds = fo.Dataset()
ds.add_samples(
    [fo.Sample(filepath=f, date=d) for f, d in zip(filepaths, dates)]
)

# Example data
query_date = datetime(2021, 8, 24, 2, 0, 1)
query_delta = timedelta(minutes=30)
```

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

### Install Super Gradients

Source: https://docs.voxel51.com/integrations/super_gradients.html

Install the super-gradients package using pip to get started.

```bash
pip install super-gradients

```

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

### setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.bdd.html

Performs any necessary setup before exporting the first sample in the dataset.

```APIDOC
setup()

    Performs any necessary setup before exporting the first sample in the dataset.
```

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

### quickstart

Source: https://docs.voxel51.com/api/fiftyone.utils.html

Initializes a FiftyOne quickstart environment.

```APIDOC
## quickstart()

### Description
Initializes a FiftyOne quickstart environment.
```

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

### setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.ingestors.html

Performs any necessary setup before importing the first sample in the dataset. This method is called when the importer's context manager interface is entered.

```APIDOC
## setup()

### Description
Performs any necessary setup before importing the first sample in the dataset. This method is called when the importer’s context manager interface is entered, `DatasetImporter.__enter__()`.

### Method
setup()
```

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

### setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.coco.html

Performs any necessary setup before exporting the first sample in the dataset. This method is called when the exporter’s context manager interface is entered.

```APIDOC
## setup()

### Description
Performs any necessary setup before exporting the first sample in the dataset.
This method is called when the exporter’s context manager interface is entered, `DatasetExporter.__enter__()`.

### Parameters
None
```

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

### Launch FiftyOne App in Docker Container

Source: https://docs.voxel51.com/environments/index.html

Launch the FiftyOne App from within a running Docker container. This example loads the 'quickstart' dataset and starts the App.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")
session = fo.launch_app(dataset)
```

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

### setup

Source: https://docs.voxel51.com/api/fiftyone.utils.yolo.html

Performs any necessary setup before exporting the first sample in the dataset.

```APIDOC
setup()

    Performs any necessary setup before exporting the first sample in the dataset.
    This method is called when the exporter’s context manager interface is entered, `DatasetExporter.__enter__()`.
```

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

### Launch Quickstart with Video Dataset

Source: https://docs.voxel51.com/cli/index.html

Launches the FiftyOne quickstart specifically with a video dataset, useful for testing video-related functionalities.

```bash
fiftyone quickstart --video

```

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

### Detectron2 and PyTorch Setup

Source: https://docs.voxel51.com/tutorials/detectron2.html

Verify PyTorch and CUDA versions and check the Detectron2 installation. This setup is crucial for compatibility.

```python
import torch, detectron2
!nvcc --version
TORCH_VERSION = ".".join(torch.__version__.split(".")[:2])
CUDA_VERSION = torch.__version__.split("+")[-1]
print("torch: ", TORCH_VERSION, "; cuda: ", CUDA_VERSION)
print("detectron2:", detectron2.__version__)

```

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

### QuickstartCommand

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Launches a FiftyOne quickstart.

```APIDOC
## QuickstartCommand()

### Description
Launch a FiftyOne quickstart.

### Method
Not applicable (CLI command)

### Endpoint
Not applicable (CLI command)

### Parameters
None explicitly documented for direct invocation.

### Request Example
Not applicable (CLI command)

### Response
Not applicable (CLI command)
```

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

### MediaExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the media exporter.

```APIDOC
## MediaExporter.setup()

### Description
Sets up the media exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Install FiftyOne and Albumentations

Source: https://docs.voxel51.com/integrations/albumentations.html

Install the necessary libraries for FiftyOne and Albumentations. Use the `-U` flag to ensure you get the latest versions.

```bash
$ pip install -U fiftyone albumentations

```

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

### setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.importers.html

Performs any necessary setup before importing the first sample in the dataset. This method is called when the importer’s context manager interface is entered, `DatasetImporter.__enter__()`.

```APIDOC
## setup()

### Description
Performs any necessary setup before importing the first sample in the dataset.
This method is called when the importer’s context manager interface is entered, `DatasetImporter.__enter__()`.
```

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

### Launch FiftyOne Quickstart

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Launches the FiftyOne quickstart environment. Use the `--video` flag for video datasets or `--remote` for a remote session.

```bash
fiftyone quickstart
```

```bash
fiftyone quickstart --video
```

```bash
fiftyone quickstart --remote
```

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

### Load Quickstart Dataset and Launch App (CLI)

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart.html

Use these CLI commands to load the 'quickstart' dataset and launch the FiftyOne app. This is an alternative to the Python script for quick access.

```bash
fiftyone zoo datasets load quickstart
```

```bash
fiftyone app launch quickstart
```

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

### Install FiftyOne, scikit-learn, and umap-learn

Source: https://docs.voxel51.com/tutorials/dimension_reduction.html

Install the necessary libraries for FiftyOne, scikit-learn, and umap-learn. This is a prerequisite for running the dimensionality reduction examples.

```bash
!pip install -U fiftyone scikit-learn umap-learn

```

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

### Setup Geospatial Filtering Examples

Source: https://docs.voxel51.com/cheat_sheets/filtering_cheat_sheet.html

Imports necessary libraries and defines coordinates for geospatial filtering examples. Loads a dataset with geospatial information.

```python
import fiftyone.zoo as foz

TIMES_SQUARE = [-73.9855, 40.7580]
MANHATTAN = [
    [
        [-73.949701, 40.834487],
        [-73.896611, 40.815076],
        [-73.998083, 40.696534],
        [-74.031751, 40.715273],
        [-73.949701, 40.834487],
    ]
]

ds = foz.load_zoo_dataset("quickstart-geo")
```

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

### fiftyone.utils.quickstart.quickstart

Source: https://docs.voxel51.com/api/fiftyone.utils.quickstart.html

Runs the FiftyOne quickstart process. This function loads a dataset from the Dataset Zoo, launches the FiftyOne App, and provides suggestions for dataset exploration.

```APIDOC
## quickstart()

### Description
Runs the FiftyOne quickstart. This method loads an interesting dataset from the Dataset Zoo, launches the App, and prints some suggestions for exploring the dataset.

### Method
`quickstart`([video, port, address, remote])

### Parameters
#### Path Parameters
- **video** (bool) - Optional - whether to launch a video dataset
- **port** (int) - Optional - the port number to serve the App. If None, `fiftyone.config.default_app_port` is used
- **address** (str) - Optional - the address to serve the App. If None, `fiftyone.config.default_app_address` is used
- **remote** (bool) - Optional - whether this is a remote session, and opening the App should not be attempted

### Returns
A tuple containing:
- **dataset**: the `fiftyone.core.dataset.Dataset` that was loaded
- **session**: the `fiftyone.core.session.Session` instance for the App that was launched
```

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

### VideoExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the video exporter.

```APIDOC
## VideoExporter.setup()

### Description
Sets up the video exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Load Zoo Dataset for Quickstart

Source: https://docs.voxel51.com/api/fiftyone.core.collections.html

Loads the 'quickstart' dataset from the FiftyOne Model Zoo. This is often a prerequisite for running examples that interact with datasets.

```python
import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

```

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

### Load and Visualize Quickstart 3D Dataset via CLI

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_3d.html

Use these FiftyOne CLI commands to load the 'quickstart-3d' dataset and launch an interactive visualization session.

```bash
fiftyone zoo datasets load quickstart-3d
```

```bash
fiftyone app launch quickstart-3d
```

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

### Get distinct predicted labels

Source: https://docs.voxel51.com/api/fiftyone.core.collections.html

This example shows how to get distinct values from a nested field, specifically the labels of detections within the 'predictions' field.

```python
values = dataset.distinct("predictions.detections.label")
print(values)  # list of distinct values
```

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

### Prepare Regression Data and Launch App

Source: https://docs.voxel51.com/user_guide/plots.html

Loads the 'quickstart' dataset, populates it with fake regression and weather data, evaluates the regression predictions, and then launches the FiftyOne App. This sets up the environment for exploring regression results.

```python
import random
import numpy as np

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart").select_fields().clone()

# Populate some fake regression + weather data
for idx, sample in enumerate(dataset, 1):
    ytrue = random.random() * idx
    ypred = ytrue + np.random.randn() * np.sqrt(ytrue)
    confidence = random.random()
    sample["ground_truth"] = fo.Regression(value=ytrue)
    sample["predictions"] = fo.Regression(value=ypred, confidence=confidence)
    sample["weather"] = random.choice(["sunny", "cloudy", "rainy"])
    sample.save()

# Evaluate the predictions in the `predictions` field with respect to the
# values in the `ground_truth` field
results = dataset.evaluate_regressions(
    "predictions",
    gt_field="ground_truth",
    eval_key="eval",
)

session = fo.launch_app(dataset)
```

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

### Load and View Quickstart Video Dataset via CLI

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_video.html

Commands to load the 'quickstart-video' dataset and launch the FiftyOne app directly from the command line. Requires ffmpeg for video functionality.

```bash
fiftyone zoo datasets load quickstart-video
```

```bash
fiftyone app launch quickstart-video
```

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

### LegacyFiftyOneDatasetExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the legacy FiftyOne dataset exporter.

```APIDOC
## LegacyFiftyOneDatasetExporter.setup()

### Description
Sets up the legacy FiftyOne dataset exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Get FiftyOne Plugin Info

Source: https://docs.voxel51.com/cli/index.html

Prints information about an installed FiftyOne plugin by its name or directory.

```bash
fiftyone plugins info [-h] NAME_OR_DIR
```

```bash
# Prints information about a plugin
fiftyone plugins info <name>
```

```bash
# Prints information about a plugin in a given directory
fiftyone plugins info <dir>
```

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

### DatasetImporter `setup()` Method

Source: https://docs.voxel51.com/user_guide/import_datasets.html

Implement the `setup()` method to perform any necessary setup actions before the first sample in the dataset is imported. This method is called when the importer's context manager interface is entered.

```python
    def setup(self):
        """Performs any necessary setup before importing the first sample in
        the dataset.

        This method is called when the importer's context manager interface is
        entered, :func:`DatasetImporter.__enter__`.
        """
        # Your custom setup here
        pass

```

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

### MediaDirectoryExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the media directory exporter.

```APIDOC
## MediaDirectoryExporter.setup()

### Description
Sets up the media directory exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Activate Conda Environment

Source: https://docs.voxel51.com/getting_started/self_driving/01_loading_datasets.html

Activate the newly created conda environment to start using its installed packages.

```bash
!conda activate driving_workshop
```

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

### Get Plugin Info

Source: https://docs.voxel51.com/enterprise/management_sdk.html

Fetches detailed information about a specific plugin installed in the FiftyOne Enterprise deployment.

```APIDOC
## get_plugin_info

### Description
Gets information about the specified plugin in the FiftyOne Enterprise deployment.

### Method
```python
fom.get_plugin_info(plugin_name)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Path Parameters
- **plugin_name** (str) - Required - The name of the plugin to retrieve information for.

### Request Example
```python
import fiftyone.management as fom

plugin_info = fom.get_plugin_info("my-plugin")
print(plugin_info.version)
```

### Response
#### Success Response (200)
- **plugin** (`Plugin`) - A `Plugin` instance containing the plugin's details, or `None` if the plugin is not found.

#### Response Example
```json
{
  "name": "my-plugin",
  "description": "A sample plugin",
  "version": "1.0.0",
  "fiftyone_version": "^0.5.0",
  "enabled": true,
  "operators": [
    {
      "name": "my-operator",
      "enabled": true,
      "permission": {
        "minimum_role": "USER",
        "minimum_dataset_permission": "READ_ACCESS"
      }
    }
  ]
}
```
```

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

### GenericSampleDatasetExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the generic sample dataset exporter.

```APIDOC
## GenericSampleDatasetExporter.setup()

### Description
Sets up the generic sample dataset exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Get Buffer Example

Source: https://docs.voxel51.com/api/fiftyone.brain.internal.models.simple_resnet.html

Retrieves a buffer by its fully-qualified string name. Ensures the target resolves to a torch.Tensor.

```python
get_buffer(_target : str_) → Tensor#
```

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

### Get Submodule Example

Source: https://docs.voxel51.com/api/fiftyone.brain.internal.models.simple_resnet.html

Retrieves a submodule by its fully-qualified string name. Use this for efficient submodule checks.

```python
a.get_submodule("net_b.linear")
a.get_submodule("net_b.net_c.conv")
```

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

### VideoDirectoryExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the video directory exporter.

```APIDOC
## VideoDirectoryExporter.setup()

### Description
Sets up the video directory exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### FiftyOne Operator Info

Source: https://docs.voxel51.com/cli/index.html

Prints information about operators and panels that are installed locally. Use this to get details about a specific operator or panel.

```APIDOC
## FiftyOne operators info

Prints information about operators and panels that are installed locally.

```
fiftyone operators info [-h] URI
```

### Arguments

**Positional Arguments**
- `URI`: the operator or panel URI

**Optional Arguments**
- `-h`, `--help`: show this help message and exit

### Examples

```bash
# Prints information about an operator or panel
fiftyone operators info <uri>
```
```

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

### Brain Model Management Functions

Source: https://docs.voxel51.com/api/fiftyone.brain.internal.html

Utility functions for listing, downloading, installing, loading, finding, getting, and deleting brain models.

```APIDOC
## Brain Model Management

### Description
Functions for managing brain models, including listing, downloading, and loading.

### Functions
- `list_models()`
- `list_downloaded_models()`
- `is_model_downloaded(model_name)`
- `download_model(model_name, **kwargs)`
- `install_model_requirements(model_name, **kwargs)`
- `ensure_model_requirements(model_name, **kwargs)`
- `load_model(model_name, **kwargs)`
- `find_model(model_name, **kwargs)`
- `get_model(model_name, **kwargs)`
- `delete_model(model_name, **kwargs)`
```

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

### FiftyOneCommand.setup(parser)

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Sets up the command-line arguments for the FiftyOne command.

```APIDOC
## FiftyOneCommand.setup(parser)

### Description
Setup the command-line arguments for the command.

### Method
Not applicable (Class method)

### Endpoint
Not applicable (Class method)

### Parameters
- **parser** (argparse.ArgumentParser) - Required - An argparse.ArgumentParser instance.

### Request Example
Not applicable (Class method)

### Response
Not applicable (Class method)
```

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

### Get Transform Chain via Intermediate Frame

Source: https://docs.voxel51.com/api/fiftyone.core.dataset.html?highlight=evaluate+detections

Example of computing the transformation chain from 'camera_front' to 'world' by passing through the 'ego' frame.

```python
# Get transform from camera_front to world via ego
transform = dataset.get_transform_chain(
    "camera_front", "world", intermediate_frames=["ego"]
)
```

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

### Load a Zoo Dataset

Source: https://docs.voxel51.com/api/fiftyone.core.odm.dataset.html

Loads the 'quickstart' dataset from the FiftyOne Model Zoo. This is a common starting point for exploring FiftyOne's capabilities.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")

```

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

### Get Information About a Specific FiftyOne Plugin

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Use this command to retrieve detailed information about a specific installed plugin by its name or the directory it resides in.

```bash
fiftyone plugins info <name>
```

```bash
fiftyone plugins info <dir>
```

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

### Get Submodule Example

Source: https://docs.voxel51.com/api/fiftyone.brain.internal.models.simple_resnet.html

Demonstrates how to retrieve a submodule using its fully-qualified string name. This is useful for accessing nested components within a module.

```python
A(
    (net_b): Module(
        (net_c): Module(
            (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))
        )
        (linear): Linear(in_features=100, out_features=200, bias=True)
    )
)


```

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

### setup

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Performs any necessary setup before exporting the first sample in the dataset. This method is part of the exporter interface and is called once at the beginning of the export process.

```APIDOC
## setup()

### Description
Performs any necessary setup before exporting the first sample in the dataset.

### Method
setup
```

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

### setup

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Performs any necessary setup before exporting the first sample in the dataset. This method is called when the exporter’s context manager interface is entered, `DatasetExporter.__enter__()`.

```APIDOC
setup()
    
Performs any necessary setup before exporting the first sample in the dataset.
This method is called when the exporter’s context manager interface is entered, `DatasetExporter.__enter__()`. 
```

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

### Load Quickstart Geo Dataset in Python

Source: https://docs.voxel51.com/dataset_zoo/datasets/quickstart_geo.html

Use this snippet to load the quickstart-geo dataset and launch the FiftyOne app in Python. Ensure FiftyOne is installed.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart-geo")

session = fo.launch_app(dataset)
```

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

### DatasetImporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.importers.html

Performs any necessary setup before importing the first sample in the dataset. This method is called when the importer's context manager interface is entered.

```APIDOC
## setup()

### Description
Performs any necessary setup before importing the first sample in the dataset.
This method is called when the importer’s context manager interface is entered, `DatasetImporter.__enter__()`.

### Parameters
None
```

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

### DatasetExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the dataset exporter.

```APIDOC
## DatasetExporter.setup()

### Description
Sets up the dataset exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Load Dataset with Predictions

Source: https://docs.voxel51.com/getting_started/model_evaluation/01_basic_evaluation.html

Loads the 'quickstart' dataset from the FiftyOne Zoo, which includes pre-loaded model predictions. This is a convenient way to start with a dataset ready for evaluation.

```python
import fiftyone as fo
import fiftyone.zoo as foz

dataset = foz.load_zoo_dataset("quickstart")

# View summary info about the dataset
print(dataset)

```

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

### Get Local Process Group Size

Source: https://docs.voxel51.com/api/fiftyone.utils.torch.html

Retrieves the number of processes per machine within a local process group. Useful for distributed training setups.

```python
fiftyone.utils.torch.get_local_size(_local_process_group_)
```

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

### ImageExporter.setup()

Source: https://docs.voxel51.com/api/fiftyone.utils.data.html

Sets up the image exporter.

```APIDOC
## ImageExporter.setup()

### Description
Sets up the image exporter.

### Parameters
* ****kwargs

### Returns
None
```

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

### Command.setup(parser)

Source: https://docs.voxel51.com/api/fiftyone.core.cli.html

Sets up the command-line arguments for the command.

```APIDOC
## Command.setup(parser)

### Description
Setup the command-line arguments for the command.

### Method
Not applicable (Class method)

### Endpoint
Not applicable (Class method)

### Parameters
- **parser** (argparse.ArgumentParser) - Required - An argparse.ArgumentParser instance.

### Request Example
Not applicable (Class method)

### Response
Not applicable (Class method)
```

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

### Using a Custom GenericSampleDatasetExporter

Source: https://docs.voxel51.com/user_guide/export_datasets.html

This example demonstrates how to use a custom GenericSampleDatasetExporter with FiftyOne. The exporter is invoked via its context manager, which handles setup and closing automatically.

```python
import fiftyone as fo

samples = ...
exporter = CustomGenericSampleDatasetExporter(...)

with exporter:
    exporter.log_collection(samples)

    for sample in samples:
        exporter.export_sample(sample)

```

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

### Iterate Over Module Buffers

Source: https://docs.voxel51.com/api/fiftyone.brain.internal.models.simple_resnet.html

Use this to get an iterator over module buffers, yielding their names and the buffers themselves. This example shows how to print the size of buffers named 'running_var'.

```python
>>> # xdoctest: +SKIP("undefined vars")
>>> for name, buf in self.named_buffers():
>>>     if name in ['running_var']:
>>>         print(buf.size())
```