diff --git a/docs/source/_static/css/voxel51-website.css b/docs/source/_static/css/voxel51-website.css
index c5ec9e0fbd..e85c84c486 100644
--- a/docs/source/_static/css/voxel51-website.css
+++ b/docs/source/_static/css/voxel51-website.css
@@ -74,7 +74,7 @@
   color: var(--text-primary-on-light);
 }
 
-.google-gray {
+.gray {
   color: var(--gray-dark1);
 }
 
diff --git a/docs/source/_static/images/integrations/lightning_flash.png b/docs/source/_static/images/integrations/lightning_flash.png
new file mode 100644
index 0000000000..ff8eb2165b
Binary files /dev/null and b/docs/source/_static/images/integrations/lightning_flash.png differ
diff --git a/docs/source/_static/images/integrations/open_images.png b/docs/source/_static/images/integrations/open_images.png
new file mode 100644
index 0000000000..099b3870fa
Binary files /dev/null and b/docs/source/_static/images/integrations/open_images.png differ
diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html
index b361537307..368113964a 100644
--- a/docs/source/_templates/layout.html
+++ b/docs/source/_templates/layout.html
@@ -9,11 +9,15 @@
 />
 {% endblock %} {% block custom_header %}
 <div class="container-fluid header-holder tutorials-header" id="header-holder">
-  <a class="banner" href="https://voxel51.com/#open-images">
+  <a
+    class="banner"
+    href="https://voxel51.com/docs/fiftyone/integrations/lightning_flash.html"
+  >
     <div>
       <span>
-        We are collaborating with&nbsp;<b class="google-gray">Google</b>&nbsp;to
-        support the Open Images dataset and evaluation in&nbsp;<span
+        We are collaborating with the
+        <b class="gray">PyTorch Lightning</b>&nbsp;team to support training and
+        evaluating Flash models in&nbsp;<span
           ><b style="color: var(--gray-dark3)">Fifty</b
           ><b style="color: var(--color-primary)">One</b></span
         >!
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 5fdd37dd29..90a28725a8 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -133,6 +133,16 @@
 # Path to the redirects file, relative to `source/`
 redirects_file = "redirects"
 
+# -- Options for intersphinx extension ---------------------------------------
+
+intersphinx_mapping = {
+    # including `python` autolinks things like (None) which is not desirable
+    # "python": ("https://docs.python.org/3", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+    "torch": ("https://pytorch.org/docs/stable/", None),
+    "flash": ("https://lightning-flash.readthedocs.io/en/latest", None),
+}
+
 # -- Options for HTML output -------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
diff --git a/docs/source/images/integrations/flash_embeddings.png b/docs/source/images/integrations/flash_embeddings.png
new file mode 100644
index 0000000000..05aa140b5a
Binary files /dev/null and b/docs/source/images/integrations/flash_embeddings.png differ
diff --git a/docs/source/index.rst b/docs/source/index.rst
index a769a5789a..acd68fb013 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -73,11 +73,26 @@ learn how!
     :image_src: https://voxel51.com/images/integrations/pytorch-128.png
     :image_title: PyTorch
 
+.. customimagelink::
+    :image_link: integrations/lightning_flash.html
+    :image_src: https://voxel51.com/images/integrations/pytorch-lightning-128.png
+    :image_title: PyTorch Lightning
+
 .. customimagelink::
     :image_link: recipes/adding_detections.html
     :image_src: https://voxel51.com/images/integrations/tensorflow-128.png
     :image_title: TensorFlow
 
+.. customimagelink::
+    :image_link: api/fiftyone.utils.coco.html
+    :image_src: https://voxel51.com/images/integrations/coco-128.png
+    :image_title: COCO
+
+.. customimagelink::
+    :image_link: tutorials/open_images.html
+    :image_src: https://voxel51.com/images/integrations/open-images-128.png
+    :image_title: Open Images
+
 .. customimagelink::
     :image_link: environments/index.html#notebooks
     :image_src: https://voxel51.com/images/integrations/jupyter-128.png
@@ -94,15 +109,20 @@ learn how!
     :image_title: Plotly
 
 .. customimagelink::
-    :image_link: api/fiftyone.utils.scale.html
-    :image_src: https://voxel51.com/images/integrations/scale-128.png
-    :image_title: Scale AI
+    :image_link: api/fiftyone.utils.cvat.html
+    :image_src: https://voxel51.com/images/integrations/cvat-128.png
+    :image_title: CVAT
 
 .. customimagelink::
     :image_link: api/fiftyone.utils.labelbox.html
     :image_src: https://voxel51.com/images/integrations/labelbox-128.png
     :image_title: Labelbox
 
+.. customimagelink::
+    :image_link: api/fiftyone.utils.scale.html
+    :image_src: https://voxel51.com/images/integrations/scale-128.png
+    :image_title: Scale AI
+
 .. customimagelink::
     :image_link: environments/index.html#google-cloud
     :image_src: https://voxel51.com/images/integrations/google-cloud-128.png
@@ -305,6 +325,7 @@ or reach out to us at support@voxel51.com.
    Tutorials <tutorials/index>
    Recipes <recipes/index>
    User Guide <user_guide/index>
+   Integrations <integrations/index>
    Release Notes <release-notes>
    CLI Documentation <cli/index>
    API Reference <api/fiftyone>
diff --git a/docs/source/integrations/index.rst b/docs/source/integrations/index.rst
new file mode 100644
index 0000000000..dc18027202
--- /dev/null
+++ b/docs/source/integrations/index.rst
@@ -0,0 +1,96 @@
+.. _integrations:
+
+FiftyOne Integrations
+=====================
+
+.. default-role:: code
+
+FiftyOne integrates naturally with other ML tools that you know and love. Click
+on the cards below to see how!
+
+.. Integrations cards section -----------------------------------------------------
+
+.. raw:: html
+
+    <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add tutorial cards below
+
+.. customcarditem::
+    :header: Lightning Flash
+    :description: Train Flash models on FiftyOne datasets and use the FiftyOne App to visualize and improve your Flash models, all with just a few lines of code.
+    :link: lightning_flash.html
+    :image: ../_static/images/integrations/lightning_flash.png
+    :tags: Model-Training,Model-Evaluation
+
+.. Upcoming integrations
+
+    .. customcarditem::
+        :header: Open Images Dataset
+        :description: FiftyOne is the recommended tool for downloading and exploring Google's Open Images Dataset.
+        :link: ../user_guide/dataset_zoo/datasets.html#dataset-zoo-open-images-v6
+        :image: ../_static/images/integrations/open_images.png
+        :tags: Dataset
+
+    .. customcarditem::
+        :header: COCO Dataset
+        :description: FiftyOne is the recommended tool for downloading and exploring the COCO Dataset.
+        :link: ../user_guide/dataset_zoo/datasets.html#dataset-zoo-coco-2017
+        :tags: Dataset
+
+    .. customcarditem::
+        :header: CVAT
+        :description: Use our CVAT integration to easily annotate and edit your FiftyOne datasets.
+        :link: ../user_guide/dataset_creation/datasets.html#cvatimagedataset
+        :tags: Annotation
+
+    .. customcarditem::
+        :header: Labelbox
+        :description: Use our Labelbox integration to easily annotate and edit your FiftyOne datasets.
+        :link: ../api/fiftyone.utils.labelbox.html
+        :image: https://voxel51.com/images/integrations/labelbox-128.png
+        :tags: Annotation
+
+    .. customcarditem::
+        :header: Scale AI
+        :description: Use our Scale integration to easily annotate and edit your FiftyOne datasets.
+        :link: ../api/fiftyone.utils.scale.html
+        :image: https://voxel51.com/images/integrations/scale-128.png
+        :tags: Annotation
+
+.. End of integrations cards
+
+.. raw:: html
+
+    </div>
+
+    <div class="pagination d-flex justify-content-center"></div>
+
+    </div>
+
+    </div>
+
+.. End integrations cards section -------------------------------------------------
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+    Lightning Flash <lightning_flash.rst>
diff --git a/docs/source/integrations/lightning_flash.rst b/docs/source/integrations/lightning_flash.rst
new file mode 100644
index 0000000000..7c83cd8e56
--- /dev/null
+++ b/docs/source/integrations/lightning_flash.rst
@@ -0,0 +1,591 @@
+.. _lightning-flash:
+
+Lightning Flash Integration
+===========================
+
+.. default-role:: code
+
+We've collaborated with `Grid AI <https://www.grid.ai>`_, the team behind the
+amazing `PyTorch Lightning <https://github.com/PyTorchLightning/pytorch-lightning>`_
+and `Lightning Flash <https://github.com/PyTorchLightning/lightning-flash>`_
+projects, to make it easy to train
+:class:`Flash tasks <flash:flash.core.model.Task>` on your
+:ref:`FiftyOne datasets <using-datasets>` and add predictions from your Flash
+models to your FiftyOne datasets for visualization and analysis, all in just a
+few lines of code!
+
+The following Flash tasks are supported natively by FiftyOne:
+
+- :ref:`Image classification <flash:image_classification>`
+- :ref:`Object detection <flash:object_detection>`
+- :ref:`Semantic segmentation <flash:semantic_segmentation>`
+- :ref:`Video classification <flash:video_classification>`
+- :ref:`Image embeddings <flash:image_embedder>`
+
+.. note::
+
+    As Lightning Flash adds support for additional computer vision tasks, we'll
+    roll out native support for them in FiftyOne via this integration!
+
+.. _flash-install:
+
+Setup
+_____
+
+In order to use the Lightning Flash integration, you'll need to
+`install Flash <https://lightning-flash.readthedocs.io/en/latest/installation.html>`_:
+
+.. code-block:: shell
+
+    pip install lightning-flash
+
+.. _flash-model-training:
+
+Model training
+______________
+
+You can easily train or finetune a Flash
+:class:`Task<flash:flash.core.model.Task>` on your
+:ref:`FiftyOne datasets <using-datasets>` with just a few lines of code using
+Flash's builtin
+:meth:`DataModule.from_fiftyone() <flash:flash.core.data.data_module.DataModule.from_fiftyone>`
+method, which is implemented for each of the Flash tasks shown below.
+
+.. tabs::
+
+    .. tab:: Image classification
+
+        The example below finetunes a Flash
+        :ref:`image classification task <flash:image_classification>` on a
+        FiftyOne dataset with |Classification| ground truth labels:
+
+        .. code-block:: python
+            :linenos:
+
+            from itertools import chain
+
+            from flash import Trainer
+            from flash.core.classification import FiftyOneLabels
+            from flash.core.finetuning import FreezeUnfreeze
+            from flash.image import ImageClassificationData, ImageClassifier
+
+            import fiftyone as fo
+            import fiftyone.zoo as foz
+
+            # 1 Load your FiftyOne dataset
+
+            dataset = foz.load_zoo_dataset(
+                "cifar10", split="test", max_samples=40, shuffle=True
+            )
+
+            # Here we use views into one dataset, but you can also use a different dataset
+            # for each split
+            train_dataset = dataset[:20]
+            test_dataset = dataset[20:25]
+            val_dataset = dataset[25:30]
+            predict_dataset = dataset[30:40]
+
+            # 2 Create the Datamodule
+            datamodule = ImageClassificationData.from_fiftyone(
+                train_dataset=train_dataset,
+                test_dataset=test_dataset,
+                val_dataset=val_dataset,
+                predict_dataset=predict_dataset,
+                label_field="ground_truth",
+                batch_size=4,
+                num_workers=4,
+            )
+
+            # 3 Build the model
+            model = ImageClassifier(
+                backbone="resnet18",
+                num_classes=datamodule.num_classes,
+                serializer=FiftyOneLabels(),
+            )
+
+            # 4 Create the trainer
+            trainer = Trainer(max_epochs=1, limit_train_batches=1, limit_val_batches=1)
+
+            # 5 Finetune the model
+            trainer.finetune(
+                model,
+                datamodule=datamodule,
+                strategy=FreezeUnfreeze(unfreeze_epoch=1),
+            )
+
+            # 6 Save it!
+            trainer.save_checkpoint("image_classification_model.pt")
+
+            # 7 Generate predictions
+
+            # For example purposes, we'll load a pretrained checkpoint
+            model = ImageClassifier.load_from_checkpoint(
+                "https://flash-weights.s3.amazonaws.com/image_classification_model.pt"
+            )
+            model.serializer = FiftyOneLabels()  # output FiftyOne format
+
+            predictions = trainer.predict(model, datamodule=datamodule)
+            predictions = list(chain.from_iterable(predictions)) # flatten batches
+
+            # Add predictions to FiftyOne dataset
+            predict_dataset.set_values("flash_predictions", predictions)
+
+            # 8 Analyze predictions in the App
+            session = fo.launch_app(view=predict_dataset)
+
+    .. tab:: Object detection
+
+        This example below finetunes a Flash
+        :ref:`object detection task <flash:object_detection>` on a FiftyOne
+        dataset with |Detections| ground truth labels:
+
+        .. code-block:: python
+            :linenos:
+
+            from itertools import chain
+
+            from flash import Trainer
+            from flash.image import ObjectDetectionData, ObjectDetector
+            from flash.image.detection.serialization import FiftyOneDetectionLabels
+
+            import fiftyone as fo
+            import fiftyone.zoo as foz
+
+            # 1 Load your FiftyOne dataset
+
+            dataset = foz.load_zoo_dataset("quickstart", max_samples=40, shuffle=True)
+
+            # Here we use views into one dataset, but you can also use a different dataset
+            # for each split
+            train_dataset = dataset[:20]
+            test_dataset = dataset[20:25]
+            val_dataset = dataset[25:30]
+            predict_dataset = dataset[30:40]
+
+            # 2 Create the Datamodule
+            datamodule = ObjectDetectionData.from_fiftyone(
+                train_dataset=train_dataset,
+                test_dataset=test_dataset,
+                val_dataset=val_dataset,
+                predict_dataset=predict_dataset,
+                label_field="ground_truth",
+                batch_size=4,
+                num_workers=4,
+            )
+
+            # 3 Build the model
+            model = ObjectDetector(
+                model="retinanet",
+                num_classes=datamodule.num_classes,
+                serializer=FiftyOneDetectionLabels(),
+            )
+
+            # 4 Create the trainer
+            trainer = Trainer(max_epochs=1, limit_train_batches=1, limit_val_batches=1)
+
+            # 5 Finetune the model
+            trainer.finetune(model, datamodule=datamodule)
+
+            # 6 Save it!
+            trainer.save_checkpoint("object_detection_model.pt")
+
+            # 7 Generate predictions
+
+            # For example purposes, we'll load a pretrained checkpoint
+            model = ObjectDetector.load_from_checkpoint(
+                "https://flash-weights.s3.amazonaws.com/object_detection_model.pt"
+            )
+            model.serializer = FiftyOneDetectionLabels()  # output FiftyOne format
+
+            predictions = trainer.predict(model, datamodule=datamodule)
+            predictions = list(chain.from_iterable(predictions)) # flatten batches
+
+            # Add predictions to FiftyOne dataset
+            predict_dataset.set_values("flash_predictions", predictions)
+
+            # 8 Analyze predictions in the App
+            session = fo.launch_app(view=predict_dataset)
+
+    .. tab:: Semantic segmentation
+
+        This example below finetunes a Flash
+        :ref:`semantic segmentation task <flash:semantic_segmentation>` on a
+        FiftyOne dataset with |Segmentation| ground truth labels:
+
+        .. code-block:: python
+            :linenos:
+
+            from itertools import chain
+
+            from flash import Trainer
+            from flash.core.data.utils import download_data
+            from flash.image import SemanticSegmentation, SemanticSegmentationData
+            from flash.image.segmentation.serialization import FiftyOneSegmentationLabels, SegmentationLabels
+
+            import fiftyone as fo
+            import fiftyone.zoo as foz
+
+            # 1 Load your FiftyOne dataset
+
+            # source: https://www.kaggle.com/kumaresanmanickavelu/lyft-udacity-challenge
+            download_data(
+                "https://github.com/ongchinkiat/LyftPerceptionChallenge/releases/download/v0.1/carla-capture-20180513A.zip",
+                "data/"
+            )
+
+            dataset = fo.Dataset.from_dir(
+                dataset_dir="data",
+                dataset_type=fo.types.ImageSegmentationDirectory,
+                data_path="CameraRGB",
+                labels_path="CameraSeg",
+                force_grayscale=True,
+                max_samples=40,
+                shuffle=True,
+            )
+
+            # 2 Create the Datamodule
+            datamodule = SemanticSegmentationData.from_fiftyone(
+                train_dataset=dataset,
+                test_dataset=dataset,
+                val_dataset=dataset,
+                predict_dataset=dataset,
+                label_field="ground_truth",
+                batch_size=4,
+                num_workers=4,
+                image_size=(200,200),
+                num_classes=21,
+            )
+
+            # 3 Build the model
+            model = SemanticSegmentation(
+                backbone="resnet50",
+                num_classes=datamodule.num_classes,
+                serializer=SegmentationLabels(),
+            )
+
+            # 4 Create the trainer
+            trainer = Trainer(max_epochs=1, fast_dev_run=1)
+
+            # 5 Finetune the model
+            trainer.finetune(model, datamodule=datamodule, strategy="freeze")
+
+            # 6 Save it!
+            trainer.save_checkpoint("semantic_segmentation_model.pt")
+
+            # 7 Generate predictions
+
+            # For example purposes, we'll load a pretrained checkpoint
+            model = SemanticSegmentation.load_from_checkpoint(
+                "https://flash-weights.s3.amazonaws.com/semantic_segmentation_model.pt"
+            )
+            model.serializer = FiftyOneSegmentationLabels()  # output FiftyOne format
+
+            predictions = trainer.predict(model, datamodule=datamodule)
+            predictions = list(chain.from_iterable(predictions)) # flatten batches
+
+            # Add predictions to FiftyOne dataset
+            dataset.set_values("flash_predictions", predictions)
+
+            # 8 Analyze predictions in the App
+            session = fo.launch_app(dataset)
+
+    .. tab:: Video classification
+
+        The example below finetunes a Flash
+        :ref:`video classification task <flash:video_classification>` on a
+        FiftyOne dataset with |Classification| ground truth labels:
+
+        .. code-block:: python
+            :linenos:
+
+            from torch.utils.data.sampler import RandomSampler
+
+            import flash
+            from flash.core.classification import FiftyOneLabels
+            from flash.core.data.utils import download_data
+            from flash.video import VideoClassificationData, VideoClassifier
+
+            import fiftyone as fo
+
+            # 1 Download data
+            download_data("https://pl-flash-data.s3.amazonaws.com/kinetics.zip")
+
+            # 2 Load data into FiftyOne
+            # Here we use different datasets for each split, but you can also use views
+            # into the same dataset
+
+            train_dataset = fo.Dataset.from_dir(
+                "data/kinetics/train",
+                fo.types.VideoClassificationDirectoryTree,
+                label_field="ground_truth",
+                max_samples=5,
+            )
+
+            val_dataset = fo.Dataset.from_dir(
+                "data/kinetics/val",
+                fo.types.VideoClassificationDirectoryTree,
+                label_field="ground_truth",
+                max_samples=5,
+            )
+
+            predict_dataset = fo.Dataset.from_dir(
+                "data/kinetics/predict",
+                fo.types.VideoDirectory,
+                max_samples=5,
+            )
+
+            # 3 Finetune a model
+
+            classifier = VideoClassifier.load_from_checkpoint(
+                "https://flash-weights.s3.amazonaws.com/video_classification.pt",
+                pretrained=False,
+            )
+
+            datamodule = VideoClassificationData.from_fiftyone(
+                train_dataset=train_dataset,
+                val_dataset=val_dataset,
+                predict_dataset=predict_dataset,
+                label_field="ground_truth",
+                batch_size=8,
+                clip_sampler="uniform",
+                clip_duration=1,
+                video_sampler=RandomSampler,
+                decode_audio=False,
+                num_workers=8,
+            )
+
+            trainer = flash.Trainer(max_epochs=1, fast_dev_run=1)
+            trainer.finetune(classifier, datamodule=datamodule)
+            trainer.save_checkpoint("video_classification.pt")
+
+            # 4 Predict from checkpoint
+
+            # For example purposes, we'll load a pretrained checkpoint
+            classifier = VideoClassifier.load_from_checkpoint(
+                "https://flash-weights.s3.amazonaws.com/video_classification.pt",
+                pretrained=False,
+            )
+            classifier.serializer = FiftyOneLabels()
+
+            filepaths = predict_dataset.values("filepath")
+            predictions = classifier.predict(filepaths)
+
+            # Add predictions to FiftyOne dataset
+            predict_dataset.set_values("predictions", predictions)
+
+            # 5 Visualize in FiftyOne App
+            session = fo.launch_app(predict_dataset)
+
+.. _flash-model-predictions:
+
+Model predictions
+_________________
+
+Once you have a trained Flash task, you can add model predictions to a FiftyOne
+|Dataset| or |DatasetView| in just a few lines of code using either of the
+patterns below.
+
+Applying Flash models to FiftyOne datasets
+------------------------------------------
+
+The easiest way to generate predictions on a FiftyOne |Dataset| or
+|DatasetView| with a Flash model is to use the
+builtin :meth:`apply_model() <fiftyone.core.collections.SampleCollection.apply_model>`
+function, which natively accepts Flash models of any
+:ref:`supported type <lightning-flash>`.
+
+Behind the scenes, FiftyOne will construct the appropriate Flash
+:mod:`Trainer <flash:flash.core.trainer>` and FiftyOne-style
+:class:`Serializer <flash:flash.core.data.process.Serializer>` to perform the
+inference and output the predictions as |Label| instances that are added to
+your dataset.
+
+.. code-block:: python
+    :linenos:
+
+    from flash.image import ObjectDetector
+
+    import fiftyone as fo
+    import fiftyone.zoo as foz
+
+    # Load your dataset
+    dataset = foz.load_zoo_dataset("quickstart", max_samples=5)
+
+    # Load your Flash model
+    model = ObjectDetector.load_from_checkpoint(
+        "https://flash-weights.s3.amazonaws.com/object_detection_model.pt"
+    )
+
+    # Predict!
+    dataset.apply_model(model, label_field="flash_predictions")
+
+    # Visualize
+    session = fo.launch_app(dataset)
+
+.. note::
+
+    When performing inference with Flash models, you can pass additional
+    arguments like ``gpus=8`` to
+    :meth:`apply_model() <fiftyone.core.collections.SampleCollection.apply_model>`,
+    which are used to initialize the Flash
+    :mod:`Trainer <flash:flash.core.trainer>` to configure distributed and/or
+    parallelized inference!
+
+Manually adding predictions
+---------------------------
+
+If you've already loaded your datasets into Flash
+:class:`DataModules <flash:flash.core.data.data_module.DataModule>` without
+using FiftyOne, you can still easily use FiftyOne to analyze your model's
+predictions by swapping out your model's default
+:class:`Serializer <flash:flash.core.data.process.Serializer>` for the
+:ref:`FiftyOne-style serializer <flash:fiftyone_labels>` of the appropriate
+type.
+
+Flash models with FiftyOne serializers will directly return predictions as
+|Label| objects that you can easily add to your FiftyOne datasets via
+:meth:`set_values() <fiftyone.core.collections.SampleCollection.set_values>`.
+
+.. code-block:: python
+    :linenos:
+
+    from itertools import chain
+
+    import fiftyone as fo
+    import fiftyone.zoo as foz
+
+    from flash import Trainer
+    from flash.image import ObjectDetectionData, ObjectDetector
+    from flash.image.detection.serialization import FiftyOneDetectionLabels
+
+    # Load your dataset
+    dataset = foz.load_zoo_dataset("quickstart", max_samples=5)
+
+    # Load your Flash model
+    model = ObjectDetector.load_from_checkpoint(
+        "https://flash-weights.s3.amazonaws.com/object_detection_model.pt"
+    )
+    model.serializer = FiftyOneDetectionLabels()  # output FiftyOne format
+
+    # Option 1: predict with trainer (supports distributed inference)
+    datamodule = ObjectDetectionData.from_fiftyone(predict_dataset=dataset)
+    predictions = Trainer().predict(model, datamodule=datamodule)
+    predictions = list(chain.from_iterable(predictions)) # flatten batches
+
+    # Option 2: predict with model
+    filepaths = dataset.values("filepath")
+    predictions = model.predict(filepaths)
+
+    # Add predictions to dataset
+    dataset.set_values("flash_predictions", predictions)
+
+    # Visualize in the App
+    session = fo.launch_app(dataset)
+
+.. note::
+
+    FiftyOne serializers have an optional
+    :class:`return_filepath <flash:flash.core.classification.FiftyOneLabels>`
+    flag that supports returning dicts that contain both the |Label| objects
+    and the ``filepath`` of the associated media.
+
+Specifying class names
+----------------------
+
+Generally, Flash model checkpoints will contain the class label strings for the
+model. However, if necessary, you can also explicitly pass the labels to most
+:class:`Serializer <flash:flash.core.data.process.Serializer>` instances,
+FiftyOne-style serializers included:
+
+.. code-block:: python
+    :linenos:
+
+    import fiftyone as fo
+    import fiftyone.zoo as foz
+
+    from flash.image import ObjectDetector
+    from flash.image.detection.serialization import FiftyOneDetectionLabels
+
+    # Load your dataset
+    dataset = foz.load_zoo_dataset("quickstart", max_samples=5)
+
+    # Load your Flash model
+    model = ObjectDetector.load_from_checkpoint(
+        "https://flash-weights.s3.amazonaws.com/object_detection_model.pt"
+    )
+
+    # Configure serializer with class labels
+    labels = ["label_" + str(i) for i in range(100)] # example class labels
+    model.serializer = FiftyOneDetectionLabels(labels=labels)  # output FiftyOne format
+
+    # Predict with model
+    filepaths = dataset.values("filepath")
+    predictions = model.predict(filepaths)
+
+    # Add predictions to dataset
+    dataset.set_values("flash_predictions", predictions)
+
+    print(dataset.distinct("flash_predictions.detections.label"))
+    # ['label_57', 'label_60']
+
+    # Visualize in the App
+    session = fo.launch_app(dataset)
+
+.. _flash-image-embeddings:
+
+Image embeddings
+________________
+
+If you use Lightning Flash's
+:ref:`image embeddings tasks <flash:image_embedder>` to generate feature
+vectors for your image datasets, then use can easily leverage FiftyOne's
+:ref:`dimensionality reduction <brain-embeddings-visualization>` and
+:ref:`interactive plotting <embeddings-plots>` capabilities to visualize your
+Flash model's embeddings and execute powerful workflows like
+:doc:`cluster analysis <../tutorials/image_embeddings>` and
+:ref:`similarity search <app-similarity>`, all in only a few lines of code!
+
+.. code-block:: python
+    :linenos:
+
+    import numpy as np
+
+    from flash.core.data.utils import download_data
+    from flash.image import ImageEmbedder
+
+    import fiftyone as fo
+    import fiftyone.brain as fob
+
+    # 1 Download data
+    download_data("https://pl-flash-data.s3.amazonaws.com/hymenoptera_data.zip")
+
+    # 2 Load data into FiftyOne
+    dataset = fo.Dataset.from_dir(
+        "data/hymenoptera_data/test/",
+        fo.types.ImageClassificationDirectoryTree,
+    )
+
+    # 3 Load model
+    embedder = ImageEmbedder(backbone="resnet101", embedding_dim=128)
+
+    # 4 Generate embeddings
+    filepaths = dataset.values("filepath")
+    embeddings = np.stack(embedder.predict(filepaths))
+
+    # 5 Visualize images
+    session = fo.launch_app(dataset)
+
+    # 6 Visualize image embeddings
+    results = fob.compute_visualization(dataset, embeddings=embeddings)
+    plot = results.visualize(labels="ground_truth.label")
+    plot.show()
+
+.. note::
+
+    You can also directly pass your Flash embedding model to
+    :meth:`compute_embeddings() <fiftyone.core.collections.SampleCollection.compute_embeddings>`
+    and let FiftyOne handle performing the inference!
+
+.. image:: ../images/integrations/flash_embeddings.png
+   :alt: embeddings_example
+   :align: center
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 29cd0d1551..613bb816f6 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -3,6 +3,26 @@ FiftyOne Release Notes
 
 .. default-role:: code
 
+.. _release-notes-v0.10.0:
+
+FiftyOne 0.10.0
+---------------
+*Released June 21, 2021*
+
+Core
+^^^^
+- Updated the
+  :meth:`apply_model() <fiftyone.core.collections.SampleCollection.apply_model>` and
+  :meth:`compute_embeddings() <fiftyone.core.collections.SampleCollection.compute_embeddings>`
+  methods to natively support applying
+  `Lightning Flash <https://github.com/PyTorchLightning/lightning-flash>`_
+  models to FiftyOne datasets!
+
+Docs
+^^^^
+- Added a :ref:`new page <lightning-flash>` demonstrating how to use the
+  Lightning Flash integration
+
 .. _release-notes-v0.9.4:
 
 FiftyOne 0.9.4
diff --git a/fiftyone/core/collections.py b/fiftyone/core/collections.py
index d17329aa67..db72b46126 100644
--- a/fiftyone/core/collections.py
+++ b/fiftyone/core/collections.py
@@ -1222,18 +1222,26 @@ def apply_model(
         batch_size=None,
         num_workers=None,
         skip_failures=True,
+        **trainer_kwargs,
     ):
-        """Applies the :class:`fiftyone.core.models.Model` to the samples in
-        the collection.
+        """Applies the :class:`FiftyOne model <fiftyone.core.models.Model>` or
+        :class:`Lightning Flash model <flash:flash.core.model.Task>` to the
+        samples in the collection.
 
-        This method supports all the following cases:
+        This method supports all of the following cases:
 
-        -   Applying an image model to an image collection
-        -   Applying an image model to the frames of a video collection
-        -   Applying a video model to a video collection
+        -   Applying an image :class:`fiftyone.core.models.Model` to an image
+            collection
+        -   Applying an image :class:`fiftyone.core.models.Model` to the frames
+            of a video collection
+        -   Applying a video :class:`fiftyone.core.models.Model` to a video
+            collection
+        -   Applying a :class:`flash:flash.core.model.Task` to an image or
+            video collection
 
         Args:
-            model: a :class:`fiftyone.core.models.Model`
+            model: a :class:`fiftyone.core.models.Model` or
+                :class:`flash:flash.core.model.Task`
             label_field ("predictions"): the name of the field in which to
                 store the model predictions. When performing inference on video
                 frames, the "frames." prefix is optional
@@ -1242,13 +1250,19 @@ def apply_model(
             store_logits (False): whether to store logits for the model
                 predictions. This is only supported when the provided ``model``
                 has logits, ``model.has_logits == True``
-            batch_size (None): an optional batch size to use. Only applicable
-                for image samples
-            num_workers (None): the number of workers to use when loading
-                images. Only applicable for Torch models
+            batch_size (None): an optional batch size to use, if the model
+                supports batching
+            num_workers (None): the number of workers for the
+                :class:`torch:torch.utils.data.DataLoader` to use. Only
+                applicable for Torch-based models
             skip_failures (True): whether to gracefully continue without
                 raising an error if predictions cannot be generated for a
-                sample
+                sample. Only applicable to :class:`fiftyone.core.models.Model`
+                instances
+            **trainer_kwargs: optional keyword arguments used to initialize the
+                :mod:`Trainer <flash:flash.core.trainer>` when using Flash
+                models. These can be used to, for example, configure the number
+                of GPUs to use and other distributed inference parameters
         """
         fomo.apply_model(
             self,
@@ -1259,6 +1273,7 @@ def apply_model(
             batch_size=batch_size,
             num_workers=num_workers,
             skip_failures=skip_failures,
+            **trainer_kwargs,
         )
 
     def compute_embeddings(
@@ -1268,34 +1283,49 @@ def compute_embeddings(
         batch_size=None,
         num_workers=None,
         skip_failures=True,
+        **trainer_kwargs,
     ):
         """Computes embeddings for the samples in the collection using the
-        given :class:`fiftyone.core.models.Model`.
+        given :class:`FiftyOne model <fiftyone.core.models.Model>` or
+        :class:`Lightning Flash model <flash:flash.core.model.Task>`.
 
         This method supports all the following cases:
 
-        -   Using an image model to compute embeddings for an image collection
-        -   Using an image model to compute frame embeddings for a video
-            collection
-        -   Using a video model to compute embeddings for a video collection
-
-        The ``model`` must expose embeddings, i.e.,
+        -   Using an image :class:`fiftyone.core.models.Model` to compute
+            embeddings for an image collection
+        -   Using an image :class:`fiftyone.core.models.Model` to compute frame
+            embeddings for a video collection
+        -   Using a video :class:`fiftyone.core.models.Model` to compute
+            embeddings for a video collection
+        -   Using an :ref:`ImageEmbedder <flash:image_embedder>` to compute
+            embeddings for an image collection
+
+        When using a :class:`FiftyOne model <fiftyone.core.models.Model>`, the
+        model must expose embeddings, i.e.,
         :meth:`fiftyone.core.models.Model.has_embeddings` must return ``True``.
 
         If an ``embeddings_field`` is provided, the embeddings are saved to the
         samples; otherwise, the embeddings are returned in-memory.
 
         Args:
-            model: a :class:`fiftyone.core.models.Model`
+            model: a :class:`fiftyone.core.models.Model` or
+                :class:`flash:flash.core.model.Task`
             embeddings_field (None): the name of a field in which to store the
                 embeddings. When computing video frame embeddings, the
                 "frames." prefix is optional
-            batch_size (None): an optional batch size to use. Only applicable
-                for image samples
-            num_workers (None): the number of workers to use when loading
-                images. Only applicable for Torch models
+            batch_size (None): an optional batch size to use, if the model
+                supports batching
+            num_workers (None): the number of workers for the
+                :class:`torch:torch.utils.data.DataLoader` to use. Only
+                applicable for Torch-based models
             skip_failures (True): whether to gracefully continue without
-                raising an error if embeddings cannot be generated for a sample
+                raising an error if embeddings cannot be generated for a
+                sample. Only applicable to :class:`fiftyone.core.models.Model`
+                instances
+            **trainer_kwargs: optional keyword arguments used to initialize the
+                :mod:`Trainer <flash:flash.core.trainer>` when using Flash
+                models. These can be used to, for example, configure the number
+                of GPUs to use and other distributed inference parameters
 
         Returns:
             one of the following:
@@ -1323,6 +1353,7 @@ def compute_embeddings(
             batch_size=batch_size,
             num_workers=num_workers,
             skip_failures=skip_failures,
+            **trainer_kwargs,
         )
 
     def compute_patch_embeddings(
@@ -1381,9 +1412,11 @@ def compute_patch_embeddings(
                 -   "image": use the whole image as a single patch
                 -   "error": raise an error
 
-            batch_size (None): an optional batch size to use
-            num_workers (None): the number of workers to use when loading
-                images. Only applicable for Torch models
+            batch_size (None): an optional batch size to use, if the model
+                supports batching
+            num_workers (None): the number of workers for the
+                :class:`torch:torch.utils.data.DataLoader` to use. Only
+                applicable for Torch-based models
             skip_failures (True): whether to gracefully continue without
                 raising an error if embeddings cannot be generated for a sample
 
diff --git a/fiftyone/core/models.py b/fiftyone/core/models.py
index 589a03761b..fa34910c13 100644
--- a/fiftyone/core/models.py
+++ b/fiftyone/core/models.py
@@ -6,6 +6,7 @@
 |
 """
 import contextlib
+import inspect
 import itertools
 import logging
 import warnings
@@ -29,12 +30,14 @@
 tud = fou.lazy_import("torch.utils.data")
 
 foe = fou.lazy_import("fiftyone.core.eta_utils")
-fout = fou.lazy_import("fiftyone.utils.torch")
+fouf = fou.lazy_import("fiftyone.utils.flash")
 foup = fou.lazy_import("fiftyone.utils.patches")
+fout = fou.lazy_import("fiftyone.utils.torch")
 
 
 logger = logging.getLogger(__name__)
 
+
 _ALLOWED_PATCH_TYPES = (
     fol.Detection,
     fol.Detections,
@@ -52,18 +55,23 @@ def apply_model(
     batch_size=None,
     num_workers=None,
     skip_failures=True,
+    **trainer_kwargs,
 ):
-    """Applies the given :class:`Model` to the samples in the collection.
+    """Applies the :class:`FiftyOne model <Model>` or
+    :class:`Lightning Flash model <flash:flash.core.model.Task>` to the samples
+    in the collection.
 
-    This method supports all the following cases:
+    This method supports all of the following cases:
 
-    -   Applying an image model to an image collection
-    -   Applying an image model to the frames of a video collection
-    -   Applying a video model to a video collection
+    -   Applying an image :class:`Model` to an image collection
+    -   Applying an image :class:`Model` to the frames of a video collection
+    -   Applying a video :class:`Model` to a video collection
+    -   Applying a :class:`flash:flash.core.model.Task` to an image or video
+        collection
 
     Args:
         samples: a :class:`fiftyone.core.collections.SampleCollection`
-        model: a :class:`Model`
+        model: a :class:`Model` or :class:`flash:flash.core.model.Task`
         label_field ("predictions"): the name of the field in which to store
             the model predictions. When performing inference on video frames,
             the "frames." prefix is optional
@@ -72,16 +80,34 @@ def apply_model(
         store_logits (False): whether to store logits for the model
             predictions. This is only supported when the provided ``model`` has
             logits, ``model.has_logits == True``
-        batch_size (None): an optional batch size to use. Only applicable for
-            image samples
+        batch_size (None): an optional batch size to use, if the model supports
+            batching
         num_workers (None): the number of workers to use when loading images.
-            Only applicable for Torch models
+            Only applicable for Torch-based models
         skip_failures (True): whether to gracefully continue without raising an
-            error if predictions cannot be generated for a sample
+            error if predictions cannot be generated for a sample. Only
+            applicable to :class:`Model` instances
+        **trainer_kwargs: optional keyword arguments used to initialize the
+            :mod:`Trainer <flash:flash.core.trainer>` when using Flash models.
+            These can be used to, for example, configure the number of GPUs to
+            use and other distributed inference parameters
     """
+    if _is_flash_model(model):
+        return fouf.apply_flash_model(
+            samples,
+            model,
+            label_field=label_field,
+            confidence_thresh=confidence_thresh,
+            store_logits=store_logits,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            **trainer_kwargs,
+        )
+
     if not isinstance(model, Model):
         raise ValueError(
-            "Model must be a %s instance; found %s" % (Model, type(model))
+            "Model must be a %s or %s; found %s"
+            % (Model, _BASE_FLASH_TYPE, type(model))
         )
 
     if model.media_type == "video" and samples.media_type != fom.VIDEO:
@@ -183,6 +209,17 @@ def apply_model(
         )
 
 
+_BASE_FLASH_TYPE = "flash.core.model.Task"
+
+
+def _is_flash_model(model):
+    for cls in inspect.getmro(type(model)):
+        if etau.get_class_name(cls) == _BASE_FLASH_TYPE:
+            return True
+
+    return False
+
+
 def _apply_image_model_single(
     samples, model, label_field, confidence_thresh, skip_failures
 ):
@@ -583,34 +620,46 @@ def compute_embeddings(
     batch_size=None,
     num_workers=None,
     skip_failures=True,
+    **trainer_kwargs,
 ):
     """Computes embeddings for the samples in the collection using the given
-    :class:`Model`.
+    :class:`FiftyOne model <Model>` or
+    :class:`Lightning Flash model <flash:flash.core.model.Task>`.
 
     This method supports all the following cases:
 
-    -   Using an image model to compute embeddings for an image collection
-    -   Using an image model to compute frame embeddings for a video collection
-    -   Using a video model to compute embeddings for a video collection
+    -   Using an image :class:`Model` to compute embeddings for an image
+        collection
+    -   Using an image :class:`Model` to compute frame embeddings for a video
+        collection
+    -   Using a video :class:`Model` to compute embeddings for a video
+        collection
+    -   Using an :ref:`ImageEmbedder <flash:image_embedder>` to compute
+        embeddings for an image collection
 
-    The ``model`` must expose embeddings, i.e., :meth:`Model.has_embeddings`
-    must return ``True``.
+    When using a :class:`FiftyOne model <Model>`, the model must expose
+    embeddings, i.e., :meth:`Model.has_embeddings` must return ``True``.
 
     If an ``embeddings_field`` is provided, the embeddings are saved to the
     samples; otherwise, the embeddings are returned in-memory.
 
     Args:
         samples: a :class:`fiftyone.core.collections.SampleCollection`
-        model: a :class:`Model`
+        model: a :class:`Model` or :class:`flash:flash.core.model.Task>`
         embeddings_field (None): the name of a field in which to store the
             embeddings. When computing video frame embeddings, the "frames."
             prefix is optional
-        batch_size (None): an optional batch size to use. Only applicable for
-            image samples
+        batch_size (None): an optional batch size to use, if the model supports
+            batching
         num_workers (None): the number of workers to use when loading images.
-            Only applicable for Torch models
+            Only applicable for Torch-based models
         skip_failures (True): whether to gracefully continue without raising an
-            error if embeddings cannot be generated for a sample
+            error if embeddings cannot be generated for a sample. Only
+            applicable to :class:`Model` instances
+        **trainer_kwargs: optional keyword arguments used to initialize the
+            :mod:`Trainer <flash:flash.core.trainer>` when using Flash models.
+            These can be used to, for example, configure the number of GPUs to
+            use and other distributed inference parameters
 
     Returns:
         one of the following:
@@ -630,9 +679,20 @@ def compute_embeddings(
             contain arrays of embeddings for all frames 1, 2, ... until the
             error occurred, or ``None`` if no embeddings were computed at all
     """
+    if _is_flash_model(model):
+        return fouf.compute_flash_embeddings(
+            samples,
+            model,
+            embeddings_field=embeddings_field,
+            batch_size=batch_size,
+            num_workers=num_workers,
+            **trainer_kwargs,
+        )
+
     if not isinstance(model, Model):
         raise ValueError(
-            "Model must be a %s instance; found %s" % (Model, type(model))
+            "Model must be a %s or %s; found %s"
+            % (Model, _BASE_FLASH_TYPE, type(model))
         )
 
     if not model.has_embeddings:
@@ -1136,7 +1196,8 @@ def compute_patch_embeddings(
             -   "image": use the whole image as a single patch
             -   "error": raise an error
 
-        batch_size (None): an optional batch size to use
+        batch_size (None): an optional batch size to use, if the model supports
+            batching
         num_workers (None): the number of workers to use when loading images.
             Only applicable for Torch models
         skip_failures (True): whether to gracefully continue without raising an
diff --git a/fiftyone/core/plots/matplotlib.py b/fiftyone/core/plots/matplotlib.py
index bf042b4157..1032af4dc9 100644
--- a/fiftyone/core/plots/matplotlib.py
+++ b/fiftyone/core/plots/matplotlib.py
@@ -1125,29 +1125,18 @@ def _plot_map_background(ax, locations, api_key, map_type, show_scale_bar):
 
 def _ensure_salem():
     # pip installing `salem` does not automatically install these...
-    required_packages = [
-        "salem",
-        "pyproj",
-        "netCDF4",
-        "xarray",
-        "shapely",
-        "descartes",
-        "pandas",
-        "motionless",
-    ]
-
-    missing_packages = []
-    for pkg in required_packages:
-        try:
-            etau.ensure_package(pkg)
-        except:
-            missing_packages.append(pkg)
-
-    if missing_packages:
-        raise ImportError(
-            "The requested operation requires that the following packages are "
-            "installed on your machine: %s" % (tuple(missing_packages),)
-        )
+    fou.ensure_package(
+        [
+            "salem",
+            "pyproj",
+            "netCDF4",
+            "xarray",
+            "shapely",
+            "descartes",
+            "pandas",
+            "motionless",
+        ]
+    )
 
 
 salem = fou.lazy_import("salem", callback=_ensure_salem)
diff --git a/fiftyone/core/plots/plotly.py b/fiftyone/core/plots/plotly.py
index 3ed0131a51..18186d9e3b 100644
--- a/fiftyone/core/plots/plotly.py
+++ b/fiftyone/core/plots/plotly.py
@@ -22,6 +22,7 @@
 import fiftyone.core.expressions as foe
 import fiftyone.core.fields as fof
 import fiftyone.core.labels as fol
+import fiftyone.core.utils as fou
 
 from .base import Plot, InteractivePlot, ResponsivePlot
 
@@ -1059,8 +1060,7 @@ def _check_plotly_jupyter_environment():
     # JupyterLab is different and I don't know how to distinguish Jupyter
     # notebooks from JupyterLab right now...
     #
-    error_level = fo.config.requirement_error_level
-    etau.ensure_package("ipywidgets>=7.5", error_level=error_level)
+    fou.ensure_package("ipywidgets>=7.5")
 
 
 class PlotlyNotebookPlot(PlotlyWidgetMixin, Plot):
diff --git a/fiftyone/core/utils.py b/fiftyone/core/utils.py
index c92218d37d..cdde7861f6 100644
--- a/fiftyone/core/utils.py
+++ b/fiftyone/core/utils.py
@@ -46,6 +46,13 @@
 logger = logging.getLogger(__name__)
 
 
+_REQUIREMENT_ERROR_SUFFIX = (
+    "If you think this error is inaccurate, you can set "
+    "`fiftyone.config.requirement_error_level` to 1 (warning) or 2 (ignore).\n"
+    "See https://voxel51.com/docs/fiftyone/user_guide/config.html for details."
+)
+
+
 def extract_kwargs_for_class(cls, kwargs):
     """Extracts keyword arguments for a class from the given dictionary of
     arguments.
@@ -261,127 +268,209 @@ def fill_patterns(string):
     return etau.fill_patterns(string, available_patterns())
 
 
-def ensure_boto3(error_msg=None):
-    """Verifies that boto3 is installed and importable.
+def ensure_package(
+    requirement_str, error_level=None, error_msg=None, log_success=False
+):
+    """Verifies that the given package is installed.
+
+    This function uses ``pkg_resources.get_distribution`` to locate the package
+    by its pip name and does not actually import the module.
+
+    Therefore, unlike :meth:`ensure_import`, ``requirement_str`` should refer
+    to the package name (e.g., "tensorflow-gpu"), not the module name
+    (e.g., "tensorflow").
 
     Args:
-        error_msg (None): an optional custom error message to print
+        requirement_str: a PEP 440 compliant package requirement, like
+            "tensorflow", "tensorflow<2", "tensorflow==2.3.0", or
+            "tensorflow>=1.13,<1.15". This can also be an iterable of multiple
+            requirements, all of which must be installed, or this can be a
+            single "|"-delimited string specifying multiple requirements, at
+            least one of which must be installed
+        error_level (None): the error level to use, defined as:
+
+            -   0: raise error if requirement is not satisfied
+            -   1: log warning if requirement is not satisifed
+            -   2: ignore unsatisifed requirements
+
+            By default, ``fiftyone.config.requirement_error_level`` is used
+        error_msg (None): an optional custom error message to use
+        log_success (False): whether to generate a log message if the
+            requirement is satisifed
 
-    Raises:
-        ImportError: if ``boto3`` could not be imported
+    Returns:
+        True/False whether the requirement is satisifed
     """
-    _ensure_import("boto3", error_msg=error_msg)
+    if error_level is None:
+        error_level = fo.config.requirement_error_level
+
+    return etau.ensure_package(
+        requirement_str,
+        error_level=error_level,
+        error_msg=error_msg,
+        error_suffix=_REQUIREMENT_ERROR_SUFFIX,
+        log_success=log_success,
+    )
 
 
-def ensure_tf(eager=False, error_msg=None):
-    """Verifies that TensorFlow is installed and importable.
+def ensure_import(
+    requirement_str, error_level=None, error_msg=None, log_success=False
+):
+    """Verifies that the given requirement is installed and importable.
+
+    This function imports the specified module and optionally enforces any
+    version requirements included in ``requirement_str``.
+
+    Therefore, unlike :meth:`ensure_package`, ``requirement_str`` should refer
+    to the module name (e.g., "tensorflow"), not the package name (e.g.,
+    "tensorflow-gpu").
+
+    Args:
+        requirement_str: a PEP 440-like module requirement, like "tensorflow",
+            "tensorflow<2", "tensorflow==2.3.0", or "tensorflow>=1.13,<1.15".
+            This can also be an iterable of multiple requirements, all of which
+            must be installed, or this can be a single "|"-delimited string
+            specifying multiple requirements, at least one of which must be
+            installed
+        error_level (None): the error level to use, defined as:
+
+            -   0: raise error if requirement is not satisfied
+            -   1: log warning if requirement is not satisifed
+            -   2: ignore unsatisifed requirements
+
+            By default, ``fiftyone.config.requirement_error_level`` is used
+        error_msg (None): an optional custom error message to use
+        log_success (False): whether to generate a log message if the
+            requirement is satisifed
+
+    Returns:
+        True/False whether the requirement is satisifed
+    """
+    if error_level is None:
+        error_level = fo.config.requirement_error_level
+
+    return etau.ensure_import(
+        requirement_str,
+        error_level=error_level,
+        error_msg=error_msg,
+        error_suffix=_REQUIREMENT_ERROR_SUFFIX,
+        log_success=log_success,
+    )
+
+
+def ensure_tf(eager=False, error_level=None, error_msg=None):
+    """Verifies that ``tensorflow`` is installed and importable.
 
     Args:
         eager (False): whether to require that TF is executing eagerly. If
             True and TF is not currently executing eagerly, this method will
             attempt to enable it
+        error_level (None): the error level to use, defined as:
+
+            -   0: raise error if requirement is not satisfied
+            -   1: log warning if requirement is not satisifed
+            -   2: ignore unsatisifed requirements
+
+            By default, ``fiftyone.config.requirement_error_level`` is used
         error_msg (None): an optional custom error message to print
 
-    Raises:
-        ImportError: if ``tensorflow`` could not be imported
+    Returns:
+        True/False whether the requirement is satisifed
     """
-    _ensure_import("tensorflow", error_msg=error_msg)
+    if error_level is None:
+        error_level = fo.config.requirement_error_level
 
-    if not eager:
-        return
+    success = ensure_import(
+        "tensorflow", error_level=error_level, error_msg=error_msg
+    )
 
-    import tensorflow as tf
+    if not success or not eager:
+        return success
 
     try:
-        if tf.executing_eagerly():
-            return
+        import tensorflow as tf
 
-        try:
-            # pylint: disable=no-member
-            tf.compat.v1.enable_eager_execution()
-        except AttributeError:
-            # pylint: disable=no-member
-            tf.enable_eager_execution()
+        if not tf.executing_eagerly():
+            try:
+                # pylint: disable=no-member
+                tf.compat.v1.enable_eager_execution()
+            except AttributeError:
+                # pylint: disable=no-member
+                tf.enable_eager_execution()
     except Exception as e:
-        raise ValueError(
-            "The requested operation requires that TensorFlow's eager "
-            "execution mode is activated. We tried to enable it but "
-            "encountered an error"
-        ) from e
+        if error_msg is None:
+            error_msg = (
+                "The requested operation requires that TensorFlow's eager "
+                "execution mode is activated. We tried to enable it but "
+                "encountered an error."
+            )
 
+        error_msg += "\n\n" + _REQUIREMENT_ERROR_SUFFIX
 
-def ensure_tfds(error_msg=None):
-    """Verifies that the ``tensorflow_datasets`` package is installed and
-    importable.
+        etau.handle_error(ValueError(error_msg), error_level, base_error=e)
 
-    Args:
-        error_msg (None): an optional custom error message to print
+        return False
 
-    Raises:
-        ImportError: if ``tensorflow_datasets`` could not be imported
-    """
-    _ensure_import("tensorflow", min_version="1.15", error_msg=error_msg)
-    _ensure_import("tensorflow_datasets", error_msg=error_msg)
+    return True
 
 
-def ensure_torch(error_msg=None):
-    """Verifies that PyTorch is installed and importable.
+def ensure_tfds(error_level=None, error_msg=None):
+    """Verifies that ``tensorflow_datasets`` is installed and importable.
 
     Args:
+        error_level (None): the error level to use, defined as:
+
+            -   0: raise error if requirement is not satisfied
+            -   1: log warning if requirement is not satisifed
+            -   2: ignore unsatisifed requirements
+
+            By default, ``fiftyone.config.requirement_error_level`` is used
         error_msg (None): an optional custom error message to print
 
-    Raises:
-        ImportError: if ``torch`` or ``torchvision`` could not be imported
+    Returns:
+        True/False whether the requirement is satisifed
     """
-    _ensure_import("torch", error_msg=error_msg)
-    _ensure_import("torchvision", error_msg=error_msg)
+    if error_level is None:
+        error_level = fo.config.requirement_error_level
+
+    success1 = ensure_import(
+        "tensorflow>=1.15", error_level=error_level, error_msg=error_msg
+    )
+    success2 = ensure_import(
+        "tensorflow_datasets", error_level=error_level, error_msg=error_msg
+    )
+
+    return success1 & success2
 
 
-def ensure_pycocotools(error_msg=None):
-    """Verifies that pycocotools is installed and importable.
+def ensure_torch(error_level=None, error_msg=None):
+    """Verifies that ``torch`` and ``torchvision`` are installed and
+    importable.
 
     Args:
-        error_msg (None): an optional custom error message to print
+        error_level (None): the error level to use, defined as:
 
-    Raises:
-        ImportError: if ``pycocotools`` could not be imported
-    """
-    _ensure_import("pycocotools", error_msg=error_msg)
+            -   0: raise error if requirement is not satisfied
+            -   1: log warning if requirement is not satisifed
+            -   2: ignore unsatisifed requirements
 
+            By default, ``fiftyone.config.requirement_error_level`` is used
+        error_msg (None): an optional custom error message to print
 
-def _ensure_import(module_name, min_version=None, error_msg=None):
-    has_min_ver = min_version is not None
+    Returns:
+        True/False whether the requirement is satisifed
+    """
+    if error_level is None:
+        error_level = fo.config.requirement_error_level
 
-    if has_min_ver:
-        min_version = packaging.version.parse(min_version)
+    success1 = ensure_import(
+        "torch", error_level=error_level, error_msg=error_msg
+    )
+    success2 = ensure_import(
+        "torchvision", error_level=error_level, error_msg=error_msg
+    )
 
-    try:
-        mod = importlib.import_module(module_name)
-    except ImportError as e:
-        if has_min_ver:
-            module_str = "%s>=%s" % (module_name, min_version)
-        else:
-            module_str = module_name
-
-        if error_msg is not None:
-            raise ImportError(error_msg) from e
-
-        raise ImportError(
-            "The requested operation requires that '%s' is installed on your "
-            "machine" % module_str,
-            name=module_name,
-        ) from e
-
-    if has_min_ver:
-        # @todo not all modules have `__version__`
-        mod_version = packaging.version.parse(mod.__version__)
-        if mod_version < min_version:
-            raise ImportError(
-                "The requested operation requires that '%s>=%s' is installed "
-                "on your machine; found '%s==%s'"
-                % (module_name, min_version, module_name, mod_version),
-                name=module_name,
-            )
+    return success1 & success2
 
 
 def lazy_import(module_name, callback=None):
diff --git a/fiftyone/utils/coco.py b/fiftyone/utils/coco.py
index 7874836e32..a40f336d28 100644
--- a/fiftyone/utils/coco.py
+++ b/fiftyone/utils/coco.py
@@ -28,7 +28,7 @@
 import fiftyone.utils.data as foud
 
 mask_utils = fou.lazy_import(
-    "pycocotools.mask", callback=fou.ensure_pycocotools
+    "pycocotools.mask", callback=lambda: fou.ensure_import("pycocotools")
 )
 
 
diff --git a/fiftyone/utils/flash.py b/fiftyone/utils/flash.py
new file mode 100644
index 0000000000..121eab67da
--- /dev/null
+++ b/fiftyone/utils/flash.py
@@ -0,0 +1,188 @@
+"""
+Utilities for working with
+`Lightning Flash <https://github.com/PyTorchLightning/lightning-flash>`_.
+
+| Copyright 2017-2021, Voxel51, Inc.
+| `voxel51.com <https://voxel51.com/>`_
+|
+"""
+import inspect
+import itertools
+
+import numpy as np
+
+import fiftyone.core.metadata as fom
+import fiftyone.core.utils as fou
+
+fou.ensure_import("flash>=0.4")
+import flash
+import flash.core.classification as fc
+import flash.image as fi
+import flash.image.detection.serialization as fds
+import flash.image.segmentation.serialization as fss
+
+
+_SUPPORTED_MODELS = (
+    fi.ImageClassifier,
+    fi.ObjectDetector,
+    fi.SemanticSegmentation,
+)
+
+_SUPPORTED_EMBEDDERS = (fi.ImageEmbedder,)
+
+
+def apply_flash_model(
+    samples,
+    model,
+    label_field="predictions",
+    confidence_thresh=None,
+    store_logits=False,
+    batch_size=None,
+    num_workers=None,
+    **trainer_kwargs,
+):
+    """Applies the given
+    :class:`Lightning Flash model <flash:flash.core.model.Task>` to the samples
+    in the collection.
+
+    Args:
+        samples: a :class:`fiftyone.core.collections.SampleCollection`
+        model: a :class:`flash:flash.core.model.Task`
+        label_field ("predictions"): the name of the field in which to store
+            the model predictions. When performing inference on video frames,
+            the "frames." prefix is optional
+        confidence_thresh (None): an optional confidence threshold to apply to
+            any applicable labels generated by the model
+        store_logits (False): whether to store logits for the model
+            predictions. This is only supported when the provided ``model`` has
+            logits
+        batch_size (None): an optional batch size to use. If not provided, a
+            default batch size is used
+        num_workers (None): the number of workers for the data loader to use
+        **trainer_kwargs: optional keyword arguments used to initialize the
+            :mod:`Trainer <flash:flash.core.trainer>`. These can be used to,
+            for example, configure the number of GPUs to use and other
+            distributed inference parameters
+    """
+    serializer = _get_serializer(model, confidence_thresh, store_logits)
+
+    # Running `Trainer().predict()` seems to cause `model.data_pipeline` to be
+    # garbage-collected after inference, so we restore it to its original value
+    data_pipeline = model.data_pipeline
+
+    with fou.SetAttributes(
+        model, data_pipeline=data_pipeline, serializer=serializer
+    ):
+        data_kwargs = dict(
+            preprocess=model.preprocess, num_workers=num_workers,
+        )
+        if batch_size is not None:
+            data_kwargs["batch_size"] = batch_size
+
+        datamodule = fi.ImageClassificationData.from_fiftyone(
+            predict_dataset=samples, **data_kwargs
+        )
+        predictions = flash.Trainer(**trainer_kwargs).predict(
+            model, datamodule=datamodule
+        )
+        predictions = list(itertools.chain.from_iterable(predictions))
+
+        samples.set_values(label_field, predictions)
+
+
+def compute_flash_embeddings(
+    samples,
+    model,
+    embeddings_field=None,
+    batch_size=None,
+    num_workers=None,
+    **trainer_kwargs,
+):
+    """Computes embeddings for the samples in the collection using the given
+    :class:`Lightning Flash model <flash:flash.core.model.Task>`.
+
+    This method only supports applying an
+    :ref:`ImageEmbedder <flash:image_embedder>` to an image collection.
+
+    If an ``embeddings_field`` is provided, the embeddings are saved to the
+    samples; otherwise, the embeddings are returned in-memory.
+
+    Args:
+        samples: a :class:`fiftyone.core.collections.SampleCollection`
+        model: a :class:`flash:flash.core.model.Task`
+        embeddings_field (None): the name of a field in which to store the
+            embeddings
+        batch_size (None): an optional batch size to use. If not provided, a
+            default batch size is used
+        num_workers (None): the number of workers for the data loader to use
+        **trainer_kwargs: optional keyword arguments used to initialize the
+            :mod:`Trainer <flash:flash.core.trainer>`. These can be used to,
+            for example, configure the number of GPUs to use and other
+            distributed inference parameters
+
+    Returns:
+        one of the following:
+
+        -   ``None``, if an ``embeddings_field`` is provided
+        -   a ``num_samples x num_dim`` array of embeddings, if
+            ``embeddings_field`` is None
+    """
+    if not isinstance(model, _SUPPORTED_EMBEDDERS):
+        raise ValueError(
+            "Unsupported model type %s. Supported model types are %s"
+            % (type(model), _SUPPORTED_EMBEDDERS)
+        )
+
+    # Running `Trainer().predict()` seems to cause `model.data_pipeline` to be
+    # garbage-collected after inference, so we restore it to its original value
+    data_pipeline = model.data_pipeline
+
+    with fou.SetAttributes(model, data_pipeline=data_pipeline):
+        data_kwargs = dict(
+            preprocess=model.preprocess, num_workers=num_workers,
+        )
+        if batch_size is not None:
+            data_kwargs["batch_size"] = batch_size
+
+        datamodule = fi.ImageClassificationData.from_fiftyone(
+            predict_dataset=samples, **data_kwargs
+        )
+        embeddings = flash.Trainer(**trainer_kwargs).predict(
+            model, datamodule=datamodule
+        )
+        embeddings = list(itertools.chain.from_iterable(embeddings))
+
+        if embeddings_field is not None:
+            samples.set_values(embeddings_field, embeddings)
+            return
+
+        return np.stack(embeddings)
+
+
+def _get_serializer(model, confidence_thresh, store_logits):
+    if isinstance(model, fi.ImageClassifier):
+        prev_args = dict(inspect.getmembers(model.serializer))
+
+        kwargs = {
+            "multi_label": prev_args.get("multi_label", False),
+            "store_logits": store_logits,
+        }
+
+        if "threshold" in prev_args:
+            kwargs["threshold"] = prev_args["threshold"]
+
+        if confidence_thresh is not None:
+            kwargs["threshold"] = confidence_thresh
+
+        return fc.FiftyOneLabels(**kwargs)
+
+    if isinstance(model, fi.ObjectDetector):
+        return fds.FiftyOneDetectionLabels(threshold=confidence_thresh)
+
+    if isinstance(model, fi.SemanticSegmentation):
+        return fss.FiftyOneSegmentationLabels()
+
+    raise ValueError(
+        "Unsupported model type %s. Supported model types are %s"
+        % (type(model), _SUPPORTED_MODELS)
+    )
diff --git a/fiftyone/utils/openimages.py b/fiftyone/utils/openimages.py
index 892cb97d4c..f3103f65d8 100644
--- a/fiftyone/utils/openimages.py
+++ b/fiftyone/utils/openimages.py
@@ -13,6 +13,8 @@
 import os
 import random
 
+import boto3
+import botocore
 import pandas as pd
 
 import eta.core.image as etai
@@ -25,9 +27,6 @@
 import fiftyone.core.utils as fou
 import fiftyone.utils.data as foud
 
-boto3 = fou.lazy_import("boto3", callback=fou.ensure_boto3)
-botocore = fou.lazy_import("botocore", callback=fou.ensure_boto3)
-
 
 logger = logging.getLogger(__name__)
 
diff --git a/fiftyone/zoo/datasets/torch.py b/fiftyone/zoo/datasets/torch.py
index 84ee600d5b..225f03ce67 100644
--- a/fiftyone/zoo/datasets/torch.py
+++ b/fiftyone/zoo/datasets/torch.py
@@ -394,7 +394,7 @@ def supported_splits(self):
 
     def _download_and_prepare(self, dataset_dir, scratch_dir, split):
         def download_fcn(download_dir):
-            fou.ensure_pycocotools()
+            fou.ensure_import("pycocotools")
             images_dir, anno_path = fouc.download_coco_dataset_split(
                 download_dir, split, year="2014", cleanup=True
             )
@@ -456,7 +456,7 @@ def supported_splits(self):
 
     def _download_and_prepare(self, dataset_dir, scratch_dir, split):
         def download_fcn(download_dir):
-            fou.ensure_pycocotools()
+            fou.ensure_import("pycocotools")
             images_dir, anno_path = fouc.download_coco_dataset_split(
                 download_dir, split, year="2017", cleanup=True
             )
diff --git a/fiftyone/zoo/models/__init__.py b/fiftyone/zoo/models/__init__.py
index f39c7d4736..de3654ea10 100644
--- a/fiftyone/zoo/models/__init__.py
+++ b/fiftyone/zoo/models/__init__.py
@@ -107,12 +107,13 @@ def install_zoo_model_requirements(name, error_level=None):
             refer to a specific version of the model. If no version is
             specified, the latest version of the model is used. Call
             :func:`list_zoo_models` to see the available models
-        error_level (None): the error level to use. By default,
-            ``fo.config.requirement_error_level`` is used. Valid values are:
+        error_level (None): the error level to use, defined as:
 
-            0: raise error if a requirement install fails
-            1: log warning if a requirement install fails
-            2: ignore install fails
+            -   0: raise error if a requirement install fails
+            -   1: log warning if a requirement install fails
+            -   2: ignore install fails requirements
+
+            By default, ``fo.config.requirement_error_level`` is used
     """
     if error_level is None:
         error_level = fo.config.requirement_error_level
@@ -130,13 +131,14 @@ def ensure_zoo_model_requirements(name, error_level=None, log_success=True):
             refer to a specific version of the model. If no version is
             specified, the latest version of the model is used. Call
             :func:`list_zoo_models` to see the available models
-        error_level (None): the error level to use. By default,
-            ``fo.config.requirement_error_level`` is used. Valid values are:
+        error_level (None): the error level to use when installing/ensuring
+            requirements, defined as:
 
-            0: raise error if a requirement is not satisfied
-            1: log warning if a requirement is not satisifed
-            2: ignore unsatisifed requirements
+            -   0: raise error if a requirement is not satisfied
+            -   1: log warning if a requirement is not satisifed
+            -   2: ignore unsatisifed requirements
 
+            By default, ``fo.config.requirement_error_level`` is used
         log_success (True): whether to generate a log message when a
             requirement is satisifed
     """
@@ -169,13 +171,13 @@ def load_zoo_model(
         install_requirements: whether to install any requirements before
             loading the model. By default, this is False
         error_level (None): the error level to use when installing/ensuring
-            requirements. By default, ``fo.config.requirement_error_level`` is
-            used. Valid values are:
+            requirements, defined as:
 
-            0: raise error if a requirement is not satisfied
-            1: log warning if a requirement is not satisifed
-            2: ignore unsatisifed requirements
+            -   0: raise error if a requirement is not satisfied
+            -   1: log warning if a requirement is not satisifed
+            -   2: ignore unsatisifed requirements
 
+            By default, ``fo.config.requirement_error_level`` is used
         **kwargs: keyword arguments to inject into the model's ``Config``
             instance
 
@@ -315,7 +317,11 @@ class ZooModel(etam.Model):
         date_added (None): the datetime that the model was added to the zoo
     """
 
-    pass
+    _REQUIREMENT_ERROR_SUFFIX = (
+        "If you think this error is inaccurate, you can set "
+        "`fiftyone.config.requirement_error_level` to 1 (warning) or 2 (ignore).\n"
+        "See https://voxel51.com/docs/fiftyone/user_guide/config.html for details."
+    )
 
 
 class ZooModelsManifest(etam.ModelsManifest):
diff --git a/setup.py b/setup.py
index 9444c4ad55..b53f969769 100644
--- a/setup.py
+++ b/setup.py
@@ -22,7 +22,7 @@ def finalize_options(self):
         ]
 
 
-VERSION = "0.9.4"
+VERSION = "0.10.0"
 
 
 def get_version():
@@ -94,7 +94,7 @@ def get_version():
         "xmltodict",
         "universal-analytics-python3>=1.0.1,<2",
         # internal packages
-        "voxel51-eta>=0.4.1,<0.5",
+        "voxel51-eta>=0.5,<0.6",
         # ETA dependency - restricted to a maximum version known to provide
         # wheels here because it tends to publish sdists several hours before
         # wheels. When users install FiftyOne in this window, they will need to
diff --git a/tests/isolated/import_deps_test.py b/tests/isolated/import_deps_test.py
index dcc44489e3..7b325ea76b 100644
--- a/tests/isolated/import_deps_test.py
+++ b/tests/isolated/import_deps_test.py
@@ -1,5 +1,6 @@
 """
-Test that the fiftyone core does not depend on Tensorflow or PyTorch.
+Test that the fiftyone core package does not depend on any extra packages that
+are intended to be manually installed by users.
 
 | Copyright 2017-2021, Voxel51, Inc.
 | `voxel51.com <https://voxel51.com/>`_
@@ -10,29 +11,22 @@
 import pytest
 
 
-# raise an ImportError if any of these modules are imported
+#
+# This is a list of modules that are used (typically by utilities) but which
+# are not distributed as part of the main FiftyOne package. If a user uses a
+# feature that requires them, they must manually install the packages
+#
 # https://docs.python.org/3/reference/import.html#the-module-cache
+#
 sys.modules["tensorflow"] = None
 sys.modules["tensorflow_datasets"] = None
 sys.modules["torch"] = None
 sys.modules["torchvision"] = None
+sys.modules["flash"] = None
+sys.modules["pycocotools"] = None
 
 
 def test_import_core():
-    # should not raise an ImportError, i.e. should not depend on the modules
-    # disabled above
+    # This should not raise an ImportError, i.e. should not depend on any of
+    # the modules disabled above
     import fiftyone
-
-
-def test_import_tf():
-    with pytest.raises(ImportError) as exc_info:
-        import fiftyone.utils.tf
-
-    assert exc_info.value.name == "tensorflow"
-
-
-def test_import_torch():
-    with pytest.raises(ImportError) as exc_info:
-        import fiftyone.utils.torch
-
-    assert exc_info.value.name == "torch"