notebooks/fiftyone_computer_vision.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "_0MFtpSXdsDl",
        "QsEC01N5nQxU",
        "a2kcFQFsnogO",
        "NgouLSIGfFN5",
        "Tr0U1iz9hkZT",
        "gFP8UcNdn_h9",
        "u8sqMlskzHg-",
        "b52e9HjAnj0q",
        "G38PAUl3v0c4",
        "dq1sRvbGuRil",
        "99UutTrixLb_",
        "BkLBIh8J89sp",
        "v7XseXra7J00",
        "9FkXhQ5l9EOQ",
        "L7OZHw9S976H",
        "i4iKD8A3cHox"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Getting Started with FiftyOne"
      ],
      "metadata": {
        "id": "dCSpQPrqcVdo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Intro"
      ],
      "metadata": {
        "id": "_0MFtpSXdsDl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Welcome to our workshop! Over the next hour and a half, you will learn the basics you need to start exploring, analyzing, and curating your computer vision data in FiftyOne. This notebook will walk you through how to get set up, inspecting, modifying, and visualizing data, and loading your own data into FiftyOne."
      ],
      "metadata": {
        "id": "tG4TMssEcbJJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### What is FiftyOne?"
      ],
      "metadata": {
        "id": "Jhr7j-qXjUW1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[FiftyOne](https://github.com/voxel51/fiftyone) is an open-source toolkit supercharges your machine learning workflows by enabling you to visualize datasets and interpret models faster and more effectively. Here are just a few of the things you can do with FiftyOne:"
      ],
      "metadata": {
        "id": "9zHlDwi3jX3l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   [Pre-annotate images](https://docs.voxel51.com/tutorials/image_embeddings.html)\n",
        "*   [Identify potential annotation mistakes](https://docs.voxel51.com/tutorials/detection_mistakes.html)\n",
        "*   [Search through your images with natural language queries](https://medium.com/voxel51/finding-images-with-words-92b078314ed1)\n",
        "*   [Evaluate model predictions and find edge cases](https://docs.voxel51.com/tutorials/evaluate_detections.html)\n",
        "*   [Find duplicate and near-duplicate data](https://docs.voxel51.com/tutorials/uniqueness.html#Part-1:-Finding-duplicate-and-near-duplicate-images)"
      ],
      "metadata": {
        "id": "GTHKR5uvjss8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Installation"
      ],
      "metadata": {
        "id": "kjOyBp4AlF-m"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This section walks you through how to get set up with FiftyOne. If you already have FiftyOne installed, you can skip this.\n",
        "\n",
        "If you want to follow along and run the commands in this notebook on Colab, do the following:\n",
        "\n",
        "\n",
        "*   Save a copy of this notebook to your own Google drive\n",
        "*   Start with the `!pip install fiftyone` command.\n",
        "\n",
        "To use FiftyOne, you must have a working Python installation. FiftyOne currently requires Python 3.7 - 3.10. To verify that a suitable Python version is installed and accessible, run `python --version`. Depending on your computer, your Python installation might go by `python3`.\n",
        "\n",
        "You *can* use the default Python installation on your computer. However, we recommend you use either a [virtual environment](https://docs.python.org/3/library/venv.html), or a [Conda environment](https://docs.conda.io/en/latest/)."
      ],
      "metadata": {
        "id": "FRTJaMl3nXWn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Venv"
      ],
      "metadata": {
        "id": "QsEC01N5nQxU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Venv comes with Python, so there is no need to install it separately. Change location (`cd`) into the directory in which you want your virtual environment to be:"
      ],
      "metadata": {
        "id": "YPm12uFZmniY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# cd path/to/dir"
      ],
      "metadata": {
        "id": "X424JzY7YTKN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Then create the virtual environment, with your desired env name replacing `env`:"
      ],
      "metadata": {
        "id": "1w4XgsYlYU_s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# python3 -m venv env"
      ],
      "metadata": {
        "id": "GqCdaRBiYcy6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, activate the environment:"
      ],
      "metadata": {
        "id": "OqSnjyomYeSf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# . env/bin/activate"
      ],
      "metadata": {
        "id": "FVujZ6RSYfDn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Conda"
      ],
      "metadata": {
        "id": "a2kcFQFsnogO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Conda does *not* come pre-installed, so you need to follow the instructions [here](https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html) to install either the full package, Anaconda, or lightweight Miniconda. After installing, if you are on a Mac, you must run `source <path to conda>/bin/activate` followed by `conda init zsh`. If you are not on a Mac, you can remove the `zsh` part of the command."
      ],
      "metadata": {
        "id": "ROAbS94NlNzb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can now create a new environment, with your env name replacing `myenv` in the command below:"
      ],
      "metadata": {
        "id": "o8PNfl7FZpiW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# conda create --name myenv"
      ],
      "metadata": {
        "id": "uHkKoC0RZVzh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And finally, you can activate the conda environment:"
      ],
      "metadata": {
        "id": "2_bX5--pZwdI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# conda activate myenv"
      ],
      "metadata": {
        "id": "XId-3lM0Z3Pq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Installing FiftyOne"
      ],
      "metadata": {
        "id": "L_4IZ6hLqSnv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that our environment is all set up, we can install FiftyOne with the Python package installer.\n",
        "\n",
        "The second pip install command is needed when running in Google Colab."
      ],
      "metadata": {
        "id": "EqcoFXVHqWd2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pUiILXnRcDtV"
      },
      "outputs": [],
      "source": [
        "!pip install fiftyone"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install fiftyone-db-ubuntu2204"
      ],
      "metadata": {
        "id": "L9Q6zmd9cmA7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And just like that we are ready to load Fiftyone! Whether you're in a Python interpreter or a notebook (IPython, Jupyter, Colab, etc.), you can import FiftyOne with"
      ],
      "metadata": {
        "id": "aHJuQrAuqdSB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import fiftyone as fo"
      ],
      "metadata": {
        "id": "XDZmgurwq6nu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If the above command runs without throwing an error, you are good to go! If you'd like, you can also import fiftyone without the alias `fo`, i.e. with `import fiftyone`. That being said, we recommend using the alias - it will save you a lot of keystrokes!"
      ],
      "metadata": {
        "id": "5mFKBlxfrUVt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can print the module to see where it is located on your device:"
      ],
      "metadata": {
        "id": "dXXr2CGurtne"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(fo)"
      ],
      "metadata": {
        "id": "mdXXdnhsrRYw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "2Q-K2VA6rDw4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## A trip to the zoo"
      ],
      "metadata": {
        "id": "vXS6HId6rKdG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you want to start exploring FiftyOne's capabilities without loading in your own data or model, FiftyOne has you covered.\n",
        "\n",
        "The [FiftyOne Dataset Zoo](https://docs.voxel51.com/user_guide/dataset_zoo/index.html) houses many of the most popular computer vision datasets, including MNIST, COCO, and Open Images. You can load these datasets - or subsets of these datasets - with a single line of code.\n",
        "\n",
        "The [FiftyOne Model Zoo](https://docs.voxel51.com/user_guide/model_zoo/index.html) similarly allows you to easily load dozens of standard computer vision models, including AlexNet, Faster-RCNN, and CLIP.\n",
        "\n",
        "We'll start our exploration with these zoos."
      ],
      "metadata": {
        "id": "NJw6geOewI3P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's import the zoo module from FiftyOne:"
      ],
      "metadata": {
        "id": "Sj1rodgorKvu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import fiftyone.zoo as foz"
      ],
      "metadata": {
        "id": "WzxMQSO5rK14"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can then use built-in methods to list all of the available datasets and models, any of which we can load (and download if necessary) with a single line of code."
      ],
      "metadata": {
        "id": "o17RAU7-rK75"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "foz.list_zoo_datasets()"
      ],
      "metadata": {
        "id": "yiE768inrLB3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa254c97-0e1d-42db-ca43-25559bb08293"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['activitynet-100',\n",
              " 'activitynet-200',\n",
              " 'bdd100k',\n",
              " 'caltech101',\n",
              " 'caltech256',\n",
              " 'cifar10',\n",
              " 'cifar100',\n",
              " 'cityscapes',\n",
              " 'coco-2014',\n",
              " 'coco-2017',\n",
              " 'fashion-mnist',\n",
              " 'fiw',\n",
              " 'hmdb51',\n",
              " 'imagenet-2012',\n",
              " 'imagenet-sample',\n",
              " 'kinetics-400',\n",
              " 'kinetics-600',\n",
              " 'kinetics-700',\n",
              " 'kinetics-700-2020',\n",
              " 'kitti',\n",
              " 'kitti-multiview',\n",
              " 'lfw',\n",
              " 'mnist',\n",
              " 'open-images-v6',\n",
              " 'open-images-v7',\n",
              " 'quickstart',\n",
              " 'quickstart-geo',\n",
              " 'quickstart-groups',\n",
              " 'quickstart-video',\n",
              " 'ucf101',\n",
              " 'voc-2007',\n",
              " 'voc-2012']"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also pass in a `tags` argument to this method, which then only returns datasets that contain the specified tags. This can be used to find datasets that support certain computer vision tasks, like \"detection\" or \"classification\", or to filter for datasets with a specific media type.\n",
        "\n",
        "For instance, if we want datasets with image samples that support detection tasks, we can pass in the \"image\" and \"detection\" tags:"
      ],
      "metadata": {
        "id": "j2BqAramzUQG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "foz.list_zoo_datasets(tags = [\"classification\"])"
      ],
      "metadata": {
        "id": "Tczy6brYzjni",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3e1a128-a7db-4c64-ec13-9ac22480c8b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['caltech101',\n",
              " 'caltech256',\n",
              " 'cifar10',\n",
              " 'cifar100',\n",
              " 'fashion-mnist',\n",
              " 'fiw',\n",
              " 'imagenet-2012',\n",
              " 'imagenet-sample',\n",
              " 'kinetics-400',\n",
              " 'kinetics-600',\n",
              " 'kinetics-700',\n",
              " 'kinetics-700-2020',\n",
              " 'lfw',\n",
              " 'mnist',\n",
              " 'open-images-v6',\n",
              " 'open-images-v7']"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can see a full list of tags associated with each dataset [here](https://docs.voxel51.com/user_guide/dataset_zoo/datasets.html)."
      ],
      "metadata": {
        "id": "j6ZCKnsjzuB6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "foz.list_zoo_models()"
      ],
      "metadata": {
        "id": "1u2CaGY7zGs5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67ffd705-53f8-49de-b13b-0914cea0e7b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['alexnet-imagenet-torch',\n",
              " 'centernet-hg104-1024-coco-tf2',\n",
              " 'centernet-hg104-512-coco-tf2',\n",
              " 'centernet-mobilenet-v2-fpn-512-coco-tf2',\n",
              " 'centernet-resnet101-v1-fpn-512-coco-tf2',\n",
              " 'centernet-resnet50-v1-fpn-512-coco-tf2',\n",
              " 'centernet-resnet50-v2-512-coco-tf2',\n",
              " 'clip-vit-base32-torch',\n",
              " 'deeplabv3-cityscapes-tf',\n",
              " 'deeplabv3-mnv2-cityscapes-tf',\n",
              " 'deeplabv3-resnet101-coco-torch',\n",
              " 'deeplabv3-resnet50-coco-torch',\n",
              " 'densenet121-imagenet-torch',\n",
              " 'densenet161-imagenet-torch',\n",
              " 'densenet169-imagenet-torch',\n",
              " 'densenet201-imagenet-torch',\n",
              " 'efficientdet-d0-512-coco-tf2',\n",
              " 'efficientdet-d0-coco-tf1',\n",
              " 'efficientdet-d1-640-coco-tf2',\n",
              " 'efficientdet-d1-coco-tf1',\n",
              " 'efficientdet-d2-768-coco-tf2',\n",
              " 'efficientdet-d2-coco-tf1',\n",
              " 'efficientdet-d3-896-coco-tf2',\n",
              " 'efficientdet-d3-coco-tf1',\n",
              " 'efficientdet-d4-1024-coco-tf2',\n",
              " 'efficientdet-d4-coco-tf1',\n",
              " 'efficientdet-d5-1280-coco-tf2',\n",
              " 'efficientdet-d5-coco-tf1',\n",
              " 'efficientdet-d6-1280-coco-tf2',\n",
              " 'efficientdet-d6-coco-tf1',\n",
              " 'efficientdet-d7-1536-coco-tf2',\n",
              " 'faster-rcnn-inception-resnet-atrous-v2-coco-tf',\n",
              " 'faster-rcnn-inception-resnet-atrous-v2-lowproposals-coco-tf',\n",
              " 'faster-rcnn-inception-v2-coco-tf',\n",
              " 'faster-rcnn-nas-coco-tf',\n",
              " 'faster-rcnn-nas-lowproposals-coco-tf',\n",
              " 'faster-rcnn-resnet101-coco-tf',\n",
              " 'faster-rcnn-resnet101-lowproposals-coco-tf',\n",
              " 'faster-rcnn-resnet50-coco-tf',\n",
              " 'faster-rcnn-resnet50-fpn-coco-torch',\n",
              " 'faster-rcnn-resnet50-lowproposals-coco-tf',\n",
              " 'fcn-resnet101-coco-torch',\n",
              " 'fcn-resnet50-coco-torch',\n",
              " 'googlenet-imagenet-torch',\n",
              " 'inception-resnet-v2-imagenet-tf1',\n",
              " 'inception-v3-imagenet-torch',\n",
              " 'inception-v4-imagenet-tf1',\n",
              " 'keypoint-rcnn-resnet50-fpn-coco-torch',\n",
              " 'mask-rcnn-inception-resnet-v2-atrous-coco-tf',\n",
              " 'mask-rcnn-inception-v2-coco-tf',\n",
              " 'mask-rcnn-resnet101-atrous-coco-tf',\n",
              " 'mask-rcnn-resnet50-atrous-coco-tf',\n",
              " 'mask-rcnn-resnet50-fpn-coco-torch',\n",
              " 'mnasnet0.5-imagenet-torch',\n",
              " 'mnasnet1.0-imagenet-torch',\n",
              " 'mobilenet-v2-imagenet-tf1',\n",
              " 'mobilenet-v2-imagenet-torch',\n",
              " 'resnet-v1-50-imagenet-tf1',\n",
              " 'resnet-v2-50-imagenet-tf1',\n",
              " 'resnet101-imagenet-torch',\n",
              " 'resnet152-imagenet-torch',\n",
              " 'resnet18-imagenet-torch',\n",
              " 'resnet34-imagenet-torch',\n",
              " 'resnet50-imagenet-torch',\n",
              " 'resnext101-32x8d-imagenet-torch',\n",
              " 'resnext50-32x4d-imagenet-torch',\n",
              " 'retinanet-resnet50-fpn-coco-torch',\n",
              " 'rfcn-resnet101-coco-tf',\n",
              " 'shufflenetv2-0.5x-imagenet-torch',\n",
              " 'shufflenetv2-1.0x-imagenet-torch',\n",
              " 'squeezenet-1.1-imagenet-torch',\n",
              " 'squeezenet-imagenet-torch',\n",
              " 'ssd-inception-v2-coco-tf',\n",
              " 'ssd-mobilenet-v1-coco-tf',\n",
              " 'ssd-mobilenet-v1-fpn-640-coco17',\n",
              " 'ssd-mobilenet-v1-fpn-coco-tf',\n",
              " 'ssd-mobilenet-v2-320-coco17',\n",
              " 'ssd-resnet50-fpn-coco-tf',\n",
              " 'vgg11-bn-imagenet-torch',\n",
              " 'vgg11-imagenet-torch',\n",
              " 'vgg13-bn-imagenet-torch',\n",
              " 'vgg13-imagenet-torch',\n",
              " 'vgg16-bn-imagenet-torch',\n",
              " 'vgg16-imagenet-tf1',\n",
              " 'vgg16-imagenet-torch',\n",
              " 'vgg19-bn-imagenet-torch',\n",
              " 'vgg19-imagenet-torch',\n",
              " 'wide-resnet101-2-imagenet-torch',\n",
              " 'wide-resnet50-2-imagenet-torch',\n",
              " 'yolo-v2-coco-tf1']"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will start with the Quickstart Dataset, which we can load with the `load_zoo_dataset()` method:"
      ],
      "metadata": {
        "id": "X_cPkGEVzHA1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset = foz.load_zoo_dataset(\"quickstart\")"
      ],
      "metadata": {
        "id": "JFz9lEXAzHHa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71d96ee2-e05c-4283-b7f6-94cc1467d7a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset already downloaded\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Dataset already downloaded\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading existing dataset 'quickstart'. To reload from disk, either delete the existing dataset or provide a custom `dataset_name` to use\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Loading existing dataset 'quickstart'. To reload from disk, either delete the existing dataset or provide a custom `dataset_name` to use\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.persistent = True"
      ],
      "metadata": {
        "id": "dWoUVJnSk1xM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "dataset.name = \"my-dataset\""
      ],
      "metadata": {
        "id": "1c-FRivok_Hp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.get_field_schema()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kFyCd1nwlBft",
        "outputId": "52f6fcca-9ac8-41d8-8cc2-ce53707dd0f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('id', <fiftyone.core.fields.ObjectIdField at 0x7ff57f433f10>),\n",
              "             ('filepath',\n",
              "              <fiftyone.core.fields.StringField at 0x7ff57ef86530>),\n",
              "             ('tags', <fiftyone.core.fields.ListField at 0x7ff57ef840a0>),\n",
              "             ('metadata',\n",
              "              <fiftyone.core.fields.EmbeddedDocumentField at 0x7ff57ef852a0>),\n",
              "             ('ground_truth',\n",
              "              <fiftyone.core.fields.EmbeddedDocumentField at 0x7ff57f4338e0>),\n",
              "             ('uniqueness',\n",
              "              <fiftyone.core.fields.FloatField at 0x7ff57ef870a0>),\n",
              "             ('predictions',\n",
              "              <fiftyone.core.fields.EmbeddedDocumentField at 0x7ff57ef858d0>)])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exploring the App"
      ],
      "metadata": {
        "id": "gLHBt8eszHM1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that we have a dataset to work with, let's launch the FiftyOne App and visualize the data. To do so, we create a *session*, which is an instance of the App, using the `launch_app()` command, with our dataset passed in:"
      ],
      "metadata": {
        "id": "H2bw2ujgzHR8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fo"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D7NntHOMcugX",
        "outputId": "e205e5dd-3267-410e-aeee-5daed1d27033"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<module 'fiftyone' from '/usr/local/lib/python3.8/dist-packages/fiftyone/__init__.py'>"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "session = fo.launch_app(dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "7wMWsvDpzHWr",
        "outputId": "59ebd43d-f203-46b4-c845-69812f567234"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "<style>\n",
              "\n",
              "@import url(\"https://fonts.googleapis.com/css2?family=Palanquin&display=swap\");\n",
              "\n",
              "body, html {\n",
              "  margin: 0;\n",
              "  padding: 0;\n",
              "  width: 100%;\n",
              "}\n",
              "\n",
              "#focontainer-2f10af27-c3d1-4b84-bdd9-b373bdffebb6 {\n",
              "  position: relative;\n",
              "  height: px;\n",
              "  display: block !important;\n",
              "}\n",
              "#foactivate-2f10af27-c3d1-4b84-bdd9-b373bdffebb6 {\n",
              "  font-weight: bold;\n",
              "  cursor: pointer;\n",
              "  font-size: 24px;\n",
              "  border-radius: 3px;\n",
              "  text-align: center;\n",
              "  padding: 0.5em;\n",
              "  color: rgb(255, 255, 255);\n",
              "  font-family: \"Palanquin\", sans-serif;\n",
              "  position: absolute;\n",
              "  left: 50%;\n",
              "  top: 50%;\n",
              "  width: 160px;\n",
              "  margin-left: -80px;\n",
              "  margin-top: -23px;\n",
              "  background: hsla(210,11%,15%, 0.8);\n",
              "  border: none;\n",
              "}\n",
              "#foactivate-2f10af27-c3d1-4b84-bdd9-b373bdffebb6:focus {\n",
              "  outline: none;\n",
              "}\n",
              "#fooverlay-2f10af27-c3d1-4b84-bdd9-b373bdffebb6 {\n",
              "  width: 100%;\n",
              "  height: 100%;\n",
              "  background: hsla(208, 7%, 46%, 0.7);\n",
              "  position: absolute;\n",
              "  top: 0;\n",
              "  left: 0;\n",
              "  display: none;\n",
              "  cursor: pointer;\n",
              "}\n",
              "</style>\n",
              "<div id=\"focontainer-2f10af27-c3d1-4b84-bdd9-b373bdffebb6\" style=\"display: none;\">\n",
              "   <div id=\"fooverlay-2f10af27-c3d1-4b84-bdd9-b373bdffebb6\">\n",
              "      <button id=\"foactivate-2f10af27-c3d1-4b84-bdd9-b373bdffebb6\" >Activate</button>\n",
              "   </div>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The images displayed in the grid are the media files that comprise our dataset. Just by launching the FiftyOne App, we can begin to explore and understand our data.\n",
        "\n",
        "There are a lot of elements here, so we'll break it down."
      ],
      "metadata": {
        "id": "7tsL25qdzHbr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Sample Visualizers"
      ],
      "metadata": {
        "id": "NgouLSIGfFN5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Click on any one of the images in the grid to pull up an expanded modal called the [image visualizer](https://docs.voxel51.com/user_guide/app.html#using-the-image-visualizer). In the image visualizer, if you hover over any of the rectangular bounding boxes, you'll see a box with a bunch of attributes, including a `label` and an `id`. Some of these - boxes delineated as `predictions` - have float-valued `confidence` attributes, while others - `ground_truth` boxes - do not.\n",
        "\n",
        "If we were working with a video dataset, the expanded modal would instead bring up a [video visualizer](https://docs.voxel51.com/user_guide/app.html#using-the-video-visualizer), which is similar, but has slightly different controls. Try this out yourself by loading the [Quickstart Video Dataset](https://docs.voxel51.com/user_guide/dataset_zoo/datasets.html#quickstart-video)!"
      ],
      "metadata": {
        "id": "ur0usXJZe34f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sidebar"
      ],
      "metadata": {
        "id": "Tr0U1iz9hkZT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tthe [sidebar](https://docs.voxel51.com/user_guide/app.html#using-the-sidebar) allows you to filter your dataset by toggling binary properties, setting lower and upper bounds on scalar properties, and selecting elements by name or `id`.\n",
        "\n",
        "You'll see a few sections, each with their own headers: `SAMPLE TAGS`, `LABEL TAGS`, `METADATA`, `LABELS`, and `PRIMITIVES`. Click on the `+` icon on the right side of any header to expand the section's contents, and the `v` symbol to expand any subsection.\n",
        "\n",
        "Play around with these settings. Expand the `ground_truth` label field, and click into the `+ filter by label` box. Click on any of the class names in the list and the images that are displayed in the grid will change - only images that contain that label will show!\n",
        "\n",
        "Now expand the `predictions` label field and drag the left end of the `confidence` slider to $0.75$. You've just filtered for high confidence predictions!"
      ],
      "metadata": {
        "id": "EjKL_mQLgYCj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Bookmark"
      ],
      "metadata": {
        "id": "gFP8UcNdn_h9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that you have some filters set in the side bar, you should see an additional, bookmark icon show up at the top of the grid. Clicking on this icon will take all of the filters you have created and synthesize them into one set of operations called a [View Stage](https://docs.voxel51.com/user_guide/using_views.html#view-stages). Once you've clicked on this, you should see a block with text on it appear in the bar at the top. Click the big `x` if you want to clear this bar."
      ],
      "metadata": {
        "id": "r_e1tTJVoB0M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### View bar"
      ],
      "metadata": {
        "id": "u8sqMlskzHg-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Click into the `+ add stage` box in the [view bar](https://docs.voxel51.com/user_guide/app.html#using-the-view-bar) at the top of the FiftyOne App. From the dropdown list that appears, click `Shuffle` and hit `Enter`. You should see the sample grid refresh. You've just shuffled your data!\n",
        "\n",
        "Go back up to the view bar. If you wanted to reset the view to the initial view of the dataset, you could click the big `x` in the upper right corner. Instead, click the right arrow `>` after the `Shuffle` block. You should see another dropdown! This time, click on `Limit`, and then enter $20$ into the prompt field, and hit return. There should now only be $20$ images visible in the grid - you have concatenated \"view stages\". If you were to press the `x` in the `Shuffle` block and keep the `Limit` block in the view bar, you'd see the grid refresh once again, and a different set of $20$ images would appear.\n",
        "\n"
      ],
      "metadata": {
        "id": "r4DzMfQOzHma"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saved Views"
      ],
      "metadata": {
        "id": "b52e9HjAnj0q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "At this point, you should have a sequence of blocks, or *stages* concatenated in the view bar. If you think this view into the data is interesting, you can save it so that if you want to load it in the future, you do not need to recreate the same sequence of operations explicitly. In FiftyOne, such views are called [*saved views*](https://docs.voxel51.com/user_guide/app.html#saving-views) To do so, click on the \"Unsaved view\" box in the upper left and select `+ Save current filters as view`."
      ],
      "metadata": {
        "id": "bqDHmg0PnmaW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the pop up, enter a name and descripion, select a color, and click \"Save view\". Now if you click on the `Unsaved view` text, you'll see this new view appear in the dropdown. Selecting this will immediately populate the grid with the contents of that view!"
      ],
      "metadata": {
        "id": "zvv7YT5qqbAg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Panels and Spaces\n",
        "\n",
        "From everything we've seen so far, the main canvas of the FiftyOne App is populated with a sample grid which displays media files associated with samples in our `Dataset` or `DatasetView`. This is but one possibility! If you click on the `+` next to the `Samples` tab at the top of the sample grid, you'll see a dropdown with two options - `Embeddings`, and `Histograms`.\n",
        "\n",
        "We won't get into embeddings here, because those require additional computation. Let's click on `Histogram`. Observe that a new tab appears next to the `Samples` tab. Click where it says \"Sample tags\" within the tab and change it to \"Labels\" to get histograms of class labels for ground truth detections and prediction detections.\n",
        "\n",
        "In general, you can have an arbitrary number of tabs, and you can drag to re-order them however you like. If you want to view the contents of multiple tabs at the same time, click on either of the icons with two boxes next to or on top of each other to horizontally or vertically divide the space of the app into \"Spaces\". You can similarly re-order, and also resize these spaces.\n",
        "\n",
        "With [plugins](https://docs.voxel51.com/plugins/index.html#fiftyone-plugins), you can design custom panels and spaces that suit your specific use cases!"
      ],
      "metadata": {
        "id": "G38PAUl3v0c4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "session.dataset = dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "bLL_ive84bWM",
        "outputId": "6af5d6e5-1d91-4fec-bb90-2eff3a5cf473"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "<style>\n",
              "\n",
              "@import url(\"https://fonts.googleapis.com/css2?family=Palanquin&display=swap\");\n",
              "\n",
              "body, html {\n",
              "  margin: 0;\n",
              "  padding: 0;\n",
              "  width: 100%;\n",
              "}\n",
              "\n",
              "#focontainer-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65 {\n",
              "  position: relative;\n",
              "  height: px;\n",
              "  display: block !important;\n",
              "}\n",
              "#foactivate-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65 {\n",
              "  font-weight: bold;\n",
              "  cursor: pointer;\n",
              "  font-size: 24px;\n",
              "  border-radius: 3px;\n",
              "  text-align: center;\n",
              "  padding: 0.5em;\n",
              "  color: rgb(255, 255, 255);\n",
              "  font-family: \"Palanquin\", sans-serif;\n",
              "  position: absolute;\n",
              "  left: 50%;\n",
              "  top: 50%;\n",
              "  width: 160px;\n",
              "  margin-left: -80px;\n",
              "  margin-top: -23px;\n",
              "  background: hsla(210,11%,15%, 0.8);\n",
              "  border: none;\n",
              "}\n",
              "#foactivate-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65:focus {\n",
              "  outline: none;\n",
              "}\n",
              "#fooverlay-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65 {\n",
              "  width: 100%;\n",
              "  height: 100%;\n",
              "  background: hsla(208, 7%, 46%, 0.7);\n",
              "  position: absolute;\n",
              "  top: 0;\n",
              "  left: 0;\n",
              "  display: none;\n",
              "  cursor: pointer;\n",
              "}\n",
              "</style>\n",
              "<div id=\"focontainer-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65\" style=\"display: none;\">\n",
              "   <div id=\"fooverlay-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65\">\n",
              "      <button id=\"foactivate-b8b811c5-4ec4-4b79-a7ee-2bc5f3418b65\" >Activate</button>\n",
              "   </div>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dataset selector"
      ],
      "metadata": {
        "id": "pXim848Vv03A"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Everything we've been doing so far only involved a single dataset. Sometimes, it is useful to work with multiple datasets, and to be able to switch back and forth between them easily. You can do this with the FiftyOne App's dataset selector. Let's see this in action."
      ],
      "metadata": {
        "id": "_QxlxeKr20eG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To illustrate this usage, let's also load the [Quickstart Video dataset](https://docs.voxel51.com/user_guide/dataset_zoo/datasets.html#quickstart-video):"
      ],
      "metadata": {
        "id": "9kVqvd7p3J5C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "video_dataset = foz.load_zoo_dataset(\"quickstart-video\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fGDDJU6H3KaI",
        "outputId": "fa5d4d32-d966-4309-fe16-faa6e3e6f9c1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading dataset to '/root/fiftyone/quickstart-video'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Downloading dataset to '/root/fiftyone/quickstart-video'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading dataset...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets.base:Downloading dataset...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " 100% |████|  281.7Mb/281.7Mb [397.2ms elapsed, 0s remaining, 709.2Mb/s]      \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:eta.core.utils: 100% |████|  281.7Mb/281.7Mb [397.2ms elapsed, 0s remaining, 709.2Mb/s]      \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting dataset...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets.base:Extracting dataset...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Parsing dataset metadata\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets.base:Parsing dataset metadata\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 10 samples\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets.base:Found 10 samples\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset info written to '/root/fiftyone/quickstart-video/info.json'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Dataset info written to '/root/fiftyone/quickstart-video/info.json'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading 'quickstart-video'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Loading 'quickstart-video'\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " 100% |███████████████████| 10/10 [16.5s elapsed, 0s remaining, 0.6 samples/s]     \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:eta.core.utils: 100% |███████████████████| 10/10 [16.5s elapsed, 0s remaining, 0.6 samples/s]     \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset 'quickstart-video' created\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.zoo.datasets:Dataset 'quickstart-video' created\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we now relaunch the app and click on the \"quickstart\" text in the upper left, you'll see a dropdown that now includes both \"quickstart\" and \"quickstart-video\"! Select \"quickstart-video\" and the contents of app will refresh. Now the samples in the grid are videos!\n",
        "\n",
        "Using this dataset selector, you can switch between any datasets that are loaded in the Python session, or have been made persistent in the database!"
      ],
      "metadata": {
        "id": "6F-AD9BF3KkB"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "PM2o8_AKQTT0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Leveraging the library"
      ],
      "metadata": {
        "id": "dq1sRvbGuRil"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Anything that you can do in the App, from filtering to tagging to saving views, can also be done using FiftyOne's software development kit (SDK). With the SDK, you can programmatically manipulate your computer vision data. The library and the app are also designed for seamless handoff - you can go back and forth between the two with ease.\n",
        "\n",
        "This section goes through some of the basics of how to explore and curate your data in Python."
      ],
      "metadata": {
        "id": "MUCyzZFVuYVM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inspecting our data"
      ],
      "metadata": {
        "id": "99UutTrixLb_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The first thing we can do is print out a summary of our dataset with Python's `print()` function:"
      ],
      "metadata": {
        "id": "ZYB-67vBuYop"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C88KkFc_uYuR",
        "outputId": "d3412ef8-bbd6-4dd8-fc92-1b9e70659d96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name:        quickstart\n",
            "Media type:  image\n",
            "Num samples: 200\n",
            "Persistent:  False\n",
            "Tags:        []\n",
            "Sample fields:\n",
            "    id:           fiftyone.core.fields.ObjectIdField\n",
            "    filepath:     fiftyone.core.fields.StringField\n",
            "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
            "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
            "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    uniqueness:   fiftyone.core.fields.FloatField\n",
            "    predictions:  fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here we can see some basic properties of the dataset, including its name, what the media type is for the media files associated with our samples, the number of samples in the dataset. The dataset also has a list of tags (empty here), and a `Persistent` attribute.\n",
        "\n",
        "This last attribute controls the dataset's [persistence](https://docs.voxel51.com/user_guide/using_datasets.html#dataset-persistence), or whether or not the dataset should be deleted from the underlying MongoDB database when the Python process is terminated. If a dataset is not persistent, then all of the changes we make will be lost when we end a Python session.\n",
        "\n",
        "There's also another group of information in the printout under the `Sample fields` heading. These are the fields that individual samples have in this dataset. We'll get to these in a moment."
      ],
      "metadata": {
        "id": "ICf7gcb8uYzr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For top-level dataset attributes, we can access (get and set) the values using the `.` syntax. For instance, to get the name:"
      ],
      "metadata": {
        "id": "vlia513buY5J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.name"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "F16THEz2uZWz",
        "outputId": "9122b670-2620-49f4-a821-43909afdb8c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'quickstart'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Or set the name:"
      ],
      "metadata": {
        "id": "4hyco37guZbh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.name = \"my_name\"\n",
        "print(dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OQUcYEGquZfs",
        "outputId": "2591ebbe-6dbe-48e6-8c61-6b07ead4392c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name:        my_name\n",
            "Media type:  image\n",
            "Num samples: 200\n",
            "Persistent:  False\n",
            "Tags:        []\n",
            "Sample fields:\n",
            "    id:           fiftyone.core.fields.ObjectIdField\n",
            "    filepath:     fiftyone.core.fields.StringField\n",
            "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
            "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
            "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    uniqueness:   fiftyone.core.fields.FloatField\n",
            "    predictions:  fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Media type: {dataset.media_type}\")\n",
        "print(f\"Tags: {dataset.tags}\")\n",
        "print(f\"Persistent: {dataset.persistent}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JfPRnImcuZj5",
        "outputId": "f4fb43c4-213a-4d30-89cb-ba4754d8b8a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Media type: image\n",
            "Tags: []\n",
            "Persistent: False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sample = dataset.first()"
      ],
      "metadata": {
        "id": "4Q8mMYY5nEVb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sample.predictions.detections[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AKRxAs9enMm8",
        "outputId": "b33dc978-0400-47f1-aa60-755969ffbab9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Detection: {\n",
              "    'id': '5f452c60ef00e6374aad9394',\n",
              "    'attributes': {},\n",
              "    'tags': [],\n",
              "    'label': 'bird',\n",
              "    'bounding_box': [\n",
              "        0.22192673683166503,\n",
              "        0.06093006531397502,\n",
              "        0.4808845520019531,\n",
              "        0.8937615712483724,\n",
              "    ],\n",
              "    'mask': None,\n",
              "    'confidence': 0.9750854969024658,\n",
              "    'index': None,\n",
              "}>"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dataset[:10].distinct(\"predictions.detections.label\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CrB0zX1ungs5",
        "outputId": "2ca9fc1e-acd7-4bda-a36c-c21dd26727e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['apple',\n",
              " 'backpack',\n",
              " 'banana',\n",
              " 'bear',\n",
              " 'bed',\n",
              " 'bird',\n",
              " 'book',\n",
              " 'bottle',\n",
              " 'bowl',\n",
              " 'cake',\n",
              " 'carrot',\n",
              " 'cat',\n",
              " 'chair',\n",
              " 'clock',\n",
              " 'cow',\n",
              " 'cup',\n",
              " 'dining table',\n",
              " 'donut',\n",
              " 'elephant',\n",
              " 'fork',\n",
              " 'handbag',\n",
              " 'horse',\n",
              " 'hot dog',\n",
              " 'knife',\n",
              " 'person',\n",
              " 'pizza',\n",
              " 'potted plant',\n",
              " 'sandwich',\n",
              " 'sheep',\n",
              " 'sink',\n",
              " 'spoon',\n",
              " 'suitcase',\n",
              " 'tie',\n",
              " 'traffic light',\n",
              " 'train',\n",
              " 'vase',\n",
              " 'wine glass']"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from fiftyone import ViewField as F"
      ],
      "metadata": {
        "id": "R8Z_LfuZoi95"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.limit_labels(\"predictions\", 1).first().predictions"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a6G_zrT5oSVR",
        "outputId": "d7783a72-4bfd-4869-aa22-9a4c67ca3ce1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Detections: {\n",
              "    'detections': [\n",
              "        <Detection: {\n",
              "            'id': '5f452c60ef00e6374aad9394',\n",
              "            'attributes': {},\n",
              "            'tags': [],\n",
              "            'label': 'bird',\n",
              "            'bounding_box': [\n",
              "                0.22192673683166503,\n",
              "                0.06093006531397502,\n",
              "                0.4808845520019531,\n",
              "                0.8937615712483724,\n",
              "            ],\n",
              "            'mask': None,\n",
              "            'confidence': 0.9750854969024658,\n",
              "            'index': None,\n",
              "        }>,\n",
              "    ],\n",
              "}>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can append tags to the dataset just as we would any list in Python:"
      ],
      "metadata": {
        "id": "GWZg1Ntg1lnt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.tags.append(\"my_tag\")"
      ],
      "metadata": {
        "id": "nA98ik8c1h9_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You may notice that we skipped over `Num samples`. If you were to try `dataset.num_samples`, you would get an error! There are multiple easy ways to programmatically get this information: you can use FiftyOne's built-in `count()` method, or you can use Python's `len()` function:"
      ],
      "metadata": {
        "id": "dIvmH4ZP1NJ1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Num samples from dataset.count(): {dataset.count()}\")\n",
        "print(f\"Num samples from len(dataset): {len(dataset)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vHhR_hNZ2Gjz",
        "outputId": "8dd44c62-8333-4bde-c567-90d878a33a9a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Num samples from dataset.count(): 200\n",
            "Num samples from len(dataset): 200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now what about the sample fields? Well, we can perform [aggregation operations](https://docs.voxel51.com/user_guide/using_aggregations.html) over these fields without looking at any specific sample. For instance, we can get the mean value for sample `uniqueness` using the `mean()` method:"
      ],
      "metadata": {
        "id": "Px7C6JpG2XXq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.mean(\"uniqueness\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xfdSefss2X9C",
        "outputId": "7120d2d3-3588-4b3e-9560-09df274693f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.4311145252372217"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Or we can list all distinct values for class labels in the ground truth field using the `distinct()` method:"
      ],
      "metadata": {
        "id": "sfXfimhV2YE4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.distinct(\"ground_truth.detections.label\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DVVyWMUf2YLA",
        "outputId": "c5e5c85a-37ee-4b83-b31f-9825c319fb78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['airplane',\n",
              " 'apple',\n",
              " 'backpack',\n",
              " 'banana',\n",
              " 'baseball glove',\n",
              " 'bear',\n",
              " 'bed',\n",
              " 'bench',\n",
              " 'bird',\n",
              " 'boat',\n",
              " 'book',\n",
              " 'bottle',\n",
              " 'bowl',\n",
              " 'broccoli',\n",
              " 'bus',\n",
              " 'cake',\n",
              " 'car',\n",
              " 'carrot',\n",
              " 'cat',\n",
              " 'cell phone',\n",
              " 'chair',\n",
              " 'clock',\n",
              " 'couch',\n",
              " 'cow',\n",
              " 'cup',\n",
              " 'dining table',\n",
              " 'dog',\n",
              " 'donut',\n",
              " 'elephant',\n",
              " 'fire hydrant',\n",
              " 'fork',\n",
              " 'frisbee',\n",
              " 'giraffe',\n",
              " 'handbag',\n",
              " 'horse',\n",
              " 'hot dog',\n",
              " 'kite',\n",
              " 'knife',\n",
              " 'laptop',\n",
              " 'microwave',\n",
              " 'motorcycle',\n",
              " 'orange',\n",
              " 'oven',\n",
              " 'parking meter',\n",
              " 'person',\n",
              " 'pizza',\n",
              " 'refrigerator',\n",
              " 'sandwich',\n",
              " 'scissors',\n",
              " 'sheep',\n",
              " 'sink',\n",
              " 'skateboard',\n",
              " 'skis',\n",
              " 'snowboard',\n",
              " 'spoon',\n",
              " 'sports ball',\n",
              " 'stop sign',\n",
              " 'suitcase',\n",
              " 'surfboard',\n",
              " 'teddy bear',\n",
              " 'tennis racket',\n",
              " 'tie',\n",
              " 'toothbrush',\n",
              " 'traffic light',\n",
              " 'train',\n",
              " 'truck',\n",
              " 'tv',\n",
              " 'umbrella',\n",
              " 'vase',\n",
              " 'wine glass',\n",
              " 'zebra']"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice here that we using the `.` syntax within the field name we passed into the aggregation method - this type of usage can be very, well, useful! There's so much more you can do with aggregations, but we'll save that for another day."
      ],
      "metadata": {
        "id": "izLhn3lR2YRe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aggregations can be nice, but sometimes you want to look at individual samples and dig a bit deeper. What better place to start than with the first sample? In a minute, we'll show you how to do this for any sample in your dataset."
      ],
      "metadata": {
        "id": "u2aJHiIb2YX4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample = dataset.first()"
      ],
      "metadata": {
        "id": "khk0JJMZ4oov"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "session.view = dataset.limit(10).view()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "RidYIKAaqdRr",
        "outputId": "7c2bf16a-8ad5-490d-a760-9cd6879fe61c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "<style>\n",
              "\n",
              "@import url(\"https://fonts.googleapis.com/css2?family=Palanquin&display=swap\");\n",
              "\n",
              "body, html {\n",
              "  margin: 0;\n",
              "  padding: 0;\n",
              "  width: 100%;\n",
              "}\n",
              "\n",
              "#focontainer-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf {\n",
              "  position: relative;\n",
              "  height: px;\n",
              "  display: block !important;\n",
              "}\n",
              "#foactivate-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf {\n",
              "  font-weight: bold;\n",
              "  cursor: pointer;\n",
              "  font-size: 24px;\n",
              "  border-radius: 3px;\n",
              "  text-align: center;\n",
              "  padding: 0.5em;\n",
              "  color: rgb(255, 255, 255);\n",
              "  font-family: \"Palanquin\", sans-serif;\n",
              "  position: absolute;\n",
              "  left: 50%;\n",
              "  top: 50%;\n",
              "  width: 160px;\n",
              "  margin-left: -80px;\n",
              "  margin-top: -23px;\n",
              "  background: hsla(210,11%,15%, 0.8);\n",
              "  border: none;\n",
              "}\n",
              "#foactivate-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf:focus {\n",
              "  outline: none;\n",
              "}\n",
              "#fooverlay-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf {\n",
              "  width: 100%;\n",
              "  height: 100%;\n",
              "  background: hsla(208, 7%, 46%, 0.7);\n",
              "  position: absolute;\n",
              "  top: 0;\n",
              "  left: 0;\n",
              "  display: none;\n",
              "  cursor: pointer;\n",
              "}\n",
              "</style>\n",
              "<div id=\"focontainer-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf\" style=\"display: none;\">\n",
              "   <div id=\"fooverlay-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf\">\n",
              "      <button id=\"foactivate-12f1fcf9-89e8-4a14-a0eb-e97ba97db8cf\" >Activate</button>\n",
              "   </div>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's take a look at this sample:"
      ],
      "metadata": {
        "id": "G-gaIcww4uz8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(sample)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vj-gA2434vD7",
        "outputId": "09e48fa8-0dd0-43c5-f4b3-a3f6f98b077b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<Sample: {\n",
            "    'id': '63fe92186c552edecf89b992',\n",
            "    'media_type': 'image',\n",
            "    'filepath': '/root/fiftyone/quickstart/data/000880.jpg',\n",
            "    'tags': ['validation'],\n",
            "    'metadata': None,\n",
            "    'ground_truth': <Detections: {\n",
            "        'detections': [\n",
            "            <Detection: {\n",
            "                'id': '5f452471ef00e6374aac53c8',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [0.21084375, 0.0034375, 0.46190625, 0.9442083333333334],\n",
            "                'mask': None,\n",
            "                'confidence': None,\n",
            "                'index': None,\n",
            "                'area': 73790.37944999996,\n",
            "                'iscrowd': 0.0,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452471ef00e6374aac53c9',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [0.74946875, 0.489375, 0.2164375, 0.23183333333333334],\n",
            "                'mask': None,\n",
            "                'confidence': None,\n",
            "                'index': None,\n",
            "                'area': 3935.7593000000006,\n",
            "                'iscrowd': 0.0,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452471ef00e6374aac53ca',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.044234375,\n",
            "                    0.5282083333333333,\n",
            "                    0.151390625,\n",
            "                    0.14145833333333335,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': None,\n",
            "                'index': None,\n",
            "                'area': 4827.32605,\n",
            "                'iscrowd': 0.0,\n",
            "            }>,\n",
            "        ],\n",
            "    }>,\n",
            "    'uniqueness': 0.8175834390151201,\n",
            "    'predictions': <Detections: {\n",
            "        'detections': [\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9394',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.22192673683166503,\n",
            "                    0.06093006531397502,\n",
            "                    0.4808845520019531,\n",
            "                    0.8937615712483724,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.9750854969024658,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9395',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.3962469816207886,\n",
            "                    0.006943931678930918,\n",
            "                    0.27418792247772217,\n",
            "                    0.46793556213378906,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.759726881980896,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9396',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.02506386339664459,\n",
            "                    0.548487663269043,\n",
            "                    0.16438478231430054,\n",
            "                    0.16736234029134114,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.6569182276725769,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9397',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.4889101028442383,\n",
            "                    0.009576511383056641,\n",
            "                    0.13802199363708495,\n",
            "                    0.2093157132466634,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.2359301745891571,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9398',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'elephant',\n",
            "                'bounding_box': [\n",
            "                    0.015171945095062256,\n",
            "                    0.555288823445638,\n",
            "                    0.1813342332839966,\n",
            "                    0.15938574473063152,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.221974179148674,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad9399',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bear',\n",
            "                'bounding_box': [\n",
            "                    0.017808181047439576,\n",
            "                    0.5488224665323893,\n",
            "                    0.17450940608978271,\n",
            "                    0.16891117095947267,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.1965726613998413,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939a',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'elephant',\n",
            "                'bounding_box': [\n",
            "                    0.16558188199996948,\n",
            "                    0.5723957061767578,\n",
            "                    0.09993256330490112,\n",
            "                    0.10098978678385416,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.18904592096805573,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939b',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'sheep',\n",
            "                'bounding_box': [\n",
            "                    0.213010573387146,\n",
            "                    0.05354320605595907,\n",
            "                    0.5153374671936035,\n",
            "                    0.8933518091837566,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.11480894684791565,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939c',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.29751906394958494,\n",
            "                    0.010790024201075237,\n",
            "                    0.3315577507019043,\n",
            "                    0.34026527404785156,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.11089690029621124,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939d',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'elephant',\n",
            "                'bounding_box': [\n",
            "                    0.08351035118103027,\n",
            "                    0.5574632008870443,\n",
            "                    0.18209288120269776,\n",
            "                    0.1426785151163737,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.0971052274107933,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939e',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.4461814880371094,\n",
            "                    0.0007838249827424685,\n",
            "                    0.209574556350708,\n",
            "                    0.309667714436849,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.08403241634368896,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad939f',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bird',\n",
            "                'bounding_box': [\n",
            "                    0.5395165920257569,\n",
            "                    0.034476550420125325,\n",
            "                    0.07703280448913574,\n",
            "                    0.16296254793802897,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.07699568569660187,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad93a0',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'bear',\n",
            "                'bounding_box': [\n",
            "                    0.217216157913208,\n",
            "                    0.05954849322636922,\n",
            "                    0.49451656341552735,\n",
            "                    0.8721434275309244,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.058097004890441895,\n",
            "                'index': None,\n",
            "            }>,\n",
            "            <Detection: {\n",
            "                'id': '5f452c60ef00e6374aad93a1',\n",
            "                'attributes': {},\n",
            "                'tags': [],\n",
            "                'label': 'sheep',\n",
            "                'bounding_box': [\n",
            "                    0.018094074726104737,\n",
            "                    0.5562847137451172,\n",
            "                    0.17362892627716064,\n",
            "                    0.15742950439453124,\n",
            "                ],\n",
            "                'mask': None,\n",
            "                'confidence': 0.0519101656973362,\n",
            "                'index': None,\n",
            "            }>,\n",
            "        ],\n",
            "    }>,\n",
            "}>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, samples can have a ton of nested data in embedded fields."
      ],
      "metadata": {
        "id": "CJ8YQEdg4vJw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can access attributes of the sample the same way we accessed attributes of the dataset."
      ],
      "metadata": {
        "id": "xy6_2q394vPy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"ID: {sample.id}\")\n",
        "print(f\"Filepath: {sample.filepath}\")\n",
        "print(f\"Tags: {sample.tags}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E-dj8j5R4vU4",
        "outputId": "3c28bebe-24d3-4565-9b07-23f1dafe1035"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ID: 63fe92186c552edecf89b992\n",
            "Filepath: /root/fiftyone/quickstart/data/000880.jpg\n",
            "Tags: ['validation']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `ground_truth` and `predictions` fields are `Detections` Label objects, each of which contains a list of `Detection` Labels. We can access the list of detections for `ground_truth` as follows:"
      ],
      "metadata": {
        "id": "ao30KYhw5fN-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample.ground_truth.detections"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4eE_abuK4vZf",
        "outputId": "3fca5a57-73e7-4f57-831b-0b9ac32368e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<Detection: {\n",
              "     'id': '5f452471ef00e6374aac53c8',\n",
              "     'attributes': {},\n",
              "     'tags': [],\n",
              "     'label': 'bird',\n",
              "     'bounding_box': [0.21084375, 0.0034375, 0.46190625, 0.9442083333333334],\n",
              "     'mask': None,\n",
              "     'confidence': None,\n",
              "     'index': None,\n",
              "     'area': 73790.37944999996,\n",
              "     'iscrowd': 0.0,\n",
              " }>, <Detection: {\n",
              "     'id': '5f452471ef00e6374aac53c9',\n",
              "     'attributes': {},\n",
              "     'tags': [],\n",
              "     'label': 'bird',\n",
              "     'bounding_box': [0.74946875, 0.489375, 0.2164375, 0.23183333333333334],\n",
              "     'mask': None,\n",
              "     'confidence': None,\n",
              "     'index': None,\n",
              "     'area': 3935.7593000000006,\n",
              "     'iscrowd': 0.0,\n",
              " }>, <Detection: {\n",
              "     'id': '5f452471ef00e6374aac53ca',\n",
              "     'attributes': {},\n",
              "     'tags': [],\n",
              "     'label': 'bird',\n",
              "     'bounding_box': [\n",
              "         0.044234375,\n",
              "         0.5282083333333333,\n",
              "         0.151390625,\n",
              "         0.14145833333333335,\n",
              "     ],\n",
              "     'mask': None,\n",
              "     'confidence': None,\n",
              "     'index': None,\n",
              "     'area': 4827.32605,\n",
              "     'iscrowd': 0.0,\n",
              " }>]"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want to get properties of a single detection, we can proceed in the same fashion:"
      ],
      "metadata": {
        "id": "PUcPF6jP4vej"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "detection = sample.ground_truth.detections[0]\n",
        "print(f\"label: {detection.label}\")\n",
        "print(f\"bounding box: {detection.bounding_box}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HZD0sjCz4vjN",
        "outputId": "fcf735db-00ec-479a-de50-e63cd4ebdf50"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "label: bird\n",
            "bounding box: [0.21084375, 0.0034375, 0.46190625, 0.9442083333333334]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we wanted to inspect and work with the $j^{th}$ sample in our dataset, we could use the `skip()` method to skip samples and then use `first()` to get the first sample in this abridged view of our dataset."
      ],
      "metadata": {
        "id": "AhGBdV5l6vgS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_10 = dataset.skip(10).first()"
      ],
      "metadata": {
        "id": "ijWYx8No7JVO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, we can also pick out a sample via its ID, or its filepath, if filepaths are uniquely specified on the dataset. For instance, let's use the sample ID and filepath of the first sample in the dataset and print out the uniqueness value of the selected samples:"
      ],
      "metadata": {
        "id": "3YelEwEg7YXt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_from_id = dataset['63fe92186c552edecf89b992']\n",
        "sample_from_fp = dataset['/root/fiftyone/quickstart/data/000880.jpg']\n",
        "\n",
        "print(f\"Original sample uniqueness: {sample.uniqueness}\")\n",
        "print(f\"Sample from ID uniqueness: {sample_from_id.uniqueness}\")\n",
        "print(f\"Sample from filepath uniqueness: {sample_from_fp.uniqueness}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lNk5kyS07JvF",
        "outputId": "6c7dc94d-061e-47d1-ed7c-22de9b450706"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original sample uniqueness: 0.8175834390151201\n",
            "Sample from ID uniqueness: 0.8175834390151201\n",
            "Sample from filepath uniqueness: 0.8175834390151201\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating views"
      ],
      "metadata": {
        "id": "BkLBIh8J89sp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Just as we filtered the contents of our dataset in the FiftyOne App to create views into our dataset, we can similarly (and to a greater extent!) create views using the Python SDK."
      ],
      "metadata": {
        "id": "hYuAuyVW8_3P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For a complete presentation of View stages, see the [User Guide section on View stages](https://docs.voxel51.com/user_guide/using_views.html#view-stages), and the [View stages cheat sheet](https://docs.voxel51.com/cheat_sheets/views_cheat_sheet.html). Here we'll just give you a taste for some of the possibilities:"
      ],
      "metadata": {
        "id": "CWyb9Hlb9XXC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can start by listing all available view stages:"
      ],
      "metadata": {
        "id": "R2xbBzfc9Xdr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.list_view_stages()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gWj10F5S9Xjw",
        "outputId": "c4d23194-7143-40a6-fe86-08c705e6f3cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['concat',\n",
              " 'exclude',\n",
              " 'exclude_by',\n",
              " 'exclude_fields',\n",
              " 'exclude_frames',\n",
              " 'exclude_groups',\n",
              " 'exclude_labels',\n",
              " 'exists',\n",
              " 'filter_field',\n",
              " 'filter_labels',\n",
              " 'filter_keypoints',\n",
              " 'geo_near',\n",
              " 'geo_within',\n",
              " 'group_by',\n",
              " 'limit',\n",
              " 'limit_labels',\n",
              " 'map_labels',\n",
              " 'set_field',\n",
              " 'match',\n",
              " 'match_frames',\n",
              " 'match_labels',\n",
              " 'match_tags',\n",
              " 'mongo',\n",
              " 'select',\n",
              " 'select_by',\n",
              " 'select_fields',\n",
              " 'select_frames',\n",
              " 'select_groups',\n",
              " 'select_group_slices',\n",
              " 'select_labels',\n",
              " 'shuffle',\n",
              " 'skip',\n",
              " 'sort_by',\n",
              " 'sort_by_similarity',\n",
              " 'take',\n",
              " 'to_patches',\n",
              " 'to_evaluation_patches',\n",
              " 'to_clips',\n",
              " 'to_frames']"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that these are the same options (different stylizing) that appeared in the view bar in the app."
      ],
      "metadata": {
        "id": "fxOec-Os99BS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can slice our data and get views containing subsets of our samples:"
      ],
      "metadata": {
        "id": "99PgF9IH-HHR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## first 20 samples:\n",
        "first20_view = dataset.limit(20)\n",
        "## or equivalently,\n",
        "first20_view = dataset[:20]\n",
        "\n",
        "\n",
        "## samples at positions 50-150 in dataset\n",
        "middle_view = dataset.skip(50).limit(100)\n",
        "## or equivalently,\n",
        "middle_view = dataset[50:150]\n",
        "\n",
        "## random selection of 10 samples\n",
        "rand10_view = dataset.take(10)\n",
        "## or equivalently, get first 10 samples in a shuffled view of the dataset\n",
        "rand10_view = dataset.shuffle()[:10]"
      ],
      "metadata": {
        "id": "YpOS5Hvf-U4s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can sort our samples by attributes, or expressions on their attributes:"
      ],
      "metadata": {
        "id": "WEIvgNow_KIz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## sort by uniqueness\n",
        "unique_view = dataset.sort_by(\"uniqueness\")\n",
        "\n",
        "## sort by number of ground truth detections\n",
        "from fiftyone import ViewField as F\n",
        "num_det_view = dataset.sort_by(F(\"ground_truth.detections\").length())"
      ],
      "metadata": {
        "id": "FduHrAC-_jnh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we had a similarity index for our data - which we can generate by running `dataset.compute_similarity(...)`, we could also sort the samples by their similarity to specific samples, for instance, to find similar images."
      ],
      "metadata": {
        "id": "VKNUnP_u_8Da"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also create a view containing only some samples, or some of the contents within samples, based on specified conditions. For instance:"
      ],
      "metadata": {
        "id": "e4FfIhca_71r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## View with only samples that contain EITHER a cat or a dog\n",
        "cat_or_dog_view =dataset.match(\n",
        "     F(\"predictions.detections.label\").contains(\n",
        "        [\"cat\",\"dog\"]\n",
        "     )\n",
        ")\n",
        "\n",
        "## View containing only predictions with confidence > 0.95\n",
        "high_conf_view = dataset.filter_labels(\"predictions\", F(\"confidence\") > 0.95)\n",
        "\n",
        "## Only keep ground truth detections that have label \"dog\"\n",
        "dog_dets_view = dataset.filter_labels(\"ground_truth\", F(\"label\") == \"dog\")"
      ],
      "metadata": {
        "id": "cjP51vYH_7o9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Modifying the data"
      ],
      "metadata": {
        "id": "v7XseXra7J00"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that we have looked at how to inspect and create views into our data, let's see how we can modify the data!"
      ],
      "metadata": {
        "id": "2djRF9Ez_6Qu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To illustrate some possibilities, we'll split our dataset in two and clone one half of it into a *new* dataset:"
      ],
      "metadata": {
        "id": "jCB2VOBr7J5U"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "C3GSUREfJBhh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_dataset = dataset[:100].clone()\n",
        "new_dataset.name = \"subset-of-quickstart\"\n",
        "\n",
        "# samples not in our new dataset\n",
        "other_samples = dataset[100:]"
      ],
      "metadata": {
        "id": "8g54NdbVICkU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(new_dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E-REzAquIa1A",
        "outputId": "f38e7e6f-9015-43d7-933c-7d3b0725d860"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name:        subset-of-quickstart\n",
            "Media type:  image\n",
            "Num samples: 100\n",
            "Persistent:  False\n",
            "Tags:        []\n",
            "Sample fields:\n",
            "    id:           fiftyone.core.fields.ObjectIdField\n",
            "    filepath:     fiftyone.core.fields.StringField\n",
            "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
            "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
            "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    uniqueness:   fiftyone.core.fields.FloatField\n",
            "    predictions:  fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can remove samples from this dataset:"
      ],
      "metadata": {
        "id": "UuBcwWAbICeG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_dataset.delete_samples(new_dataset.take(5))"
      ],
      "metadata": {
        "id": "gu3Pigm0ICEf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Count after deleting 5 samples: {new_dataset.count()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I7F9MWPYI8m-",
        "outputId": "8220e8cc-8b68-4a3d-edc1-1ee27911b124"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Count after deleting 5 samples: 95\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also add samples - if we add samples that are already in the dataset, it will create new unique IDs for them:"
      ],
      "metadata": {
        "id": "y_u5wDgzIogr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Add sample NOT present in dataset\n",
        "new_dataset.add_sample(other_samples.first())\n",
        "print(f\"Count after adding new sample: {new_dataset.count()}\")\n",
        "\n",
        "## Add samples already present in dataset\n",
        "new_dataset.add_samples(new_dataset[:10])\n",
        "print(f\"Count after adding copies of existing sample: {new_dataset.count()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Er5X0f24Ioyh",
        "outputId": "7e9069ff-480c-46cb-abcb-37a41f15e470"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Count after adding new sample: 96\n",
            " 100% |███████████████████| 10/10 [623.7ms elapsed, 0s remaining, 16.0 samples/s]      \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:eta.core.utils: 100% |███████████████████| 10/10 [623.7ms elapsed, 0s remaining, 16.0 samples/s]      \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Count after adding copies of existing sample: 106\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We could also create a new sample by specifying the path to a media file, and add this to the dataset:"
      ],
      "metadata": {
        "id": "TLAPbhlIIo7l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_sample = fo.Sample(filepath=\"path/to/image.png\")\n",
        "print(new_sample)\n",
        "new_dataset.add_sample(new_sample)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 157
        },
        "id": "qzkAHSTSKcZY",
        "outputId": "7198d0eb-b74e-4553-9082-650e75d1814b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<Sample: {\n",
            "    'id': None,\n",
            "    'media_type': 'image',\n",
            "    'filepath': '/content/path/to/image.png',\n",
            "    'tags': [],\n",
            "    'metadata': None,\n",
            "}>\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'63ffc95725064a2212c9f0e0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Indeed, this is one way to create a new dataset - if you know the paths to your media files, you can create samples and then create a new dataset out of these samples:"
      ],
      "metadata": {
        "id": "oNobCPTCLEZh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "created_dataset = fo.Dataset(name = \"from-scratch\")\n",
        "created_dataset.add_sample(new_sample)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "KfbP2M9CLRgX",
        "outputId": "2d8a692f-574e-4a91-8a2d-d07ef14f88ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'63ffca3a25064a2212c9f0e2'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also merge or add in entire directories or archives, but we won't get into all this."
      ],
      "metadata": {
        "id": "GfP6JDd8K4XB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In addition to changing the number of samples in a dataset, we can change sample contents in a variety of ways."
      ],
      "metadata": {
        "id": "M63oJAoc7J97"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can modify the contents of a field for a single sample - when we do so we must make sure to save the sample."
      ],
      "metadata": {
        "id": "bMfV-2727KCV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample = new_dataset.first()\n",
        "sample.uniqueness = 0\n",
        "sample.save()\n",
        "print(new_dataset.first().uniqueness)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sZqmzfU2L3NC",
        "outputId": "01be6d82-194b-41db-9b36-fd2ce5bd49a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can create a new field for the dataset. For instance, we could create a new field that stores the number of ground truth detections by sample:"
      ],
      "metadata": {
        "id": "--SFUfF1L3Fg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## create new field\n",
        "new_dataset.add_sample_field(\"num_gt_dets\", fo.IntField)\n",
        "\n",
        "## set field values for a view\n",
        "tmp_view = new_dataset.set_field(\"num_gt_dets\", F(\"ground_truth.detections\").length())\n",
        "\n",
        "## save these values to the dataset\n",
        "tmp_view.save()"
      ],
      "metadata": {
        "id": "c_LOJYqoL2-1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can access these values easily:"
      ],
      "metadata": {
        "id": "rA5_WzaSL2nO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_dataset.count_values(\"num_gt_dets\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FfZaJlEYNq0N",
        "outputId": "673026fb-b85b-494a-edaf-b1ad56cab0d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1: 18,\n",
              " 12: 1,\n",
              " 17: 1,\n",
              " 39: 1,\n",
              " 15: 2,\n",
              " 11: 4,\n",
              " 6: 4,\n",
              " 10: 1,\n",
              " 0: 1,\n",
              " 2: 38,\n",
              " 3: 12,\n",
              " 5: 5,\n",
              " 14: 2,\n",
              " 4: 4,\n",
              " 8: 3,\n",
              " 7: 4,\n",
              " 9: 6}"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also create a field from a list of values:"
      ],
      "metadata": {
        "id": "md7KlMoTNqsP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "rand_vals = np.random.random(new_dataset.count())\n",
        "new_dataset.set_values(\"rand_vals\", rand_vals)\n",
        "print(new_dataset)\n",
        "print(new_dataset.histogram_values(\"rand_vals\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9bBWiYnsNqTY",
        "outputId": "f4dc7ca3-3790-45ca-d150-d3fda2bbe958"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name:        subset-of-quickstart\n",
            "Media type:  image\n",
            "Num samples: 107\n",
            "Persistent:  False\n",
            "Tags:        []\n",
            "Sample fields:\n",
            "    id:           fiftyone.core.fields.ObjectIdField\n",
            "    filepath:     fiftyone.core.fields.StringField\n",
            "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
            "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
            "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    uniqueness:   fiftyone.core.fields.FloatField\n",
            "    predictions:  fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    num_gt_dets:  fiftyone.core.fields.IntField\n",
            "    rand_vals:    fiftyone.core.fields.FloatField\n",
            "([14, 8, 15, 11, 7, 8, 14, 7, 15, 8], [0.026336086103889156, 0.12292929949685238, 0.2195225128898156, 0.31611572628277884, 0.41270893967574207, 0.5093021530687053, 0.6058953664616685, 0.7024885798546318, 0.799081793247595, 0.8956750066405582, 0.9922682200335214], 0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We're still only scratching the surface, but one more possibility worth pointing out is adding labels to a dataset. We can create a label field for a specific sample:"
      ],
      "metadata": {
        "id": "y2WK2MzmPkMp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample = new_dataset.first()\n",
        "sample[\"classif\"] = fo.Classification(label = \"test_label\")\n",
        "print(new_dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roQeSFjnP1b2",
        "outputId": "b5fbab4d-b742-4d63-afc5-dd53a0fee208"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name:        subset-of-quickstart\n",
            "Media type:  image\n",
            "Num samples: 107\n",
            "Persistent:  False\n",
            "Tags:        []\n",
            "Sample fields:\n",
            "    id:           fiftyone.core.fields.ObjectIdField\n",
            "    filepath:     fiftyone.core.fields.StringField\n",
            "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
            "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
            "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    uniqueness:   fiftyone.core.fields.FloatField\n",
            "    predictions:  fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
            "    num_gt_dets:  fiftyone.core.fields.IntField\n",
            "    rand_vals:    fiftyone.core.fields.FloatField\n",
            "    classif:      fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Classification)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "And we can add, for instance, detections, to an existing list of detections:"
      ],
      "metadata": {
        "id": "ig0I43LhQRWj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample = new_dataset.first()\n",
        "dets = sample.ground_truth.detections\n",
        "\n",
        "new_det = fo.Detection(\n",
        "    label = \"my_label\",\n",
        "    bounding_box = [0.25, 0.25, 0.5, 0.5]\n",
        ")\n",
        "dets.append(new_det)\n",
        "sample[\"ground_truth\"] = fo.Detections(detections = dets)\n",
        "sample.save()\n",
        "\n",
        "labels = [\n",
        "    det.label for det in new_dataset.first().ground_truth.detections\n",
        "]\n",
        "\n",
        "print(f\"First sample GT detection labels: {labels}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LbZfi0NMQZgh",
        "outputId": "a63be7c6-f211-4a1c-9fe2-941205071ae1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First sample GT detection labels: ['bird', 'bird', 'bird', 'my_label', 'my_label']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Evaluating model predictions"
      ],
      "metadata": {
        "id": "9FkXhQ5l9EOQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Returning to our original dataset, we can evaluate the quality of the \"predictions\" compared to the ground truth detections using FiftyOne's [Evaluation API](https://docs.voxel51.com/user_guide/evaluation.html#evaluating-models). Because we are working with `Detection` labels, we will use the `evaluate_detections()` method:"
      ],
      "metadata": {
        "id": "viq0OzysRaqi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "eval_results = dataset.evaluate_detections(\n",
        "    \"predictions\", gt_field=\"ground_truth\", eval_key=\"eval\"\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KRbaROeWR8sp",
        "outputId": "542a9165-0c67-415d-ee7c-23515d62b2cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Evaluating detections...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:fiftyone.utils.eval.detection:Evaluating detections...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " 100% |█████████████████| 200/200 [46.3s elapsed, 0s remaining, 3.0 samples/s]       \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:eta.core.utils: 100% |█████████████████| 200/200 [46.3s elapsed, 0s remaining, 3.0 samples/s]       \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can then print out a report giving some high-level information about the quality of our predictions:"
      ],
      "metadata": {
        "id": "nCN79gkGSZlv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "eval_results.print_report()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k18C5KQ8SUnS",
        "outputId": "7c1b949d-8e15-4591-c95b-b3c94a2e8a94"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                precision    recall  f1-score   support\n",
            "\n",
            "      airplane       0.36      0.83      0.50        24\n",
            "         apple       0.07      1.00      0.13         2\n",
            "      backpack       0.09      0.86      0.16         7\n",
            "        banana       0.04      1.00      0.08         3\n",
            "baseball glove       0.38      0.75      0.50         4\n",
            "          bear       0.42      0.83      0.56         6\n",
            "           bed       0.05      1.00      0.09         1\n",
            "         bench       0.17      0.52      0.26        23\n",
            "       bicycle       0.00      0.00      0.00         0\n",
            "          bird       0.65      0.78      0.71       110\n",
            "          boat       0.09      0.46      0.16        37\n",
            "          book       0.07      0.91      0.13        11\n",
            "        bottle       0.10      0.90      0.18        10\n",
            "          bowl       0.16      0.93      0.28        15\n",
            "      broccoli       0.10      1.00      0.19        16\n",
            "           bus       0.06      1.00      0.12         1\n",
            "          cake       0.11      0.75      0.19         4\n",
            "           car       0.18      0.80      0.29        61\n",
            "        carrot       0.09      0.74      0.16        47\n",
            "           cat       0.43      0.94      0.59        16\n",
            "    cell phone       0.00      0.00      0.00         1\n",
            "         chair       0.07      0.48      0.13        23\n",
            "         clock       0.11      0.75      0.19         4\n",
            "         couch       0.12      1.00      0.22         4\n",
            "           cow       0.25      0.91      0.39        22\n",
            "           cup       0.18      0.81      0.30        21\n",
            "  dining table       0.08      0.93      0.15        15\n",
            "           dog       0.24      0.80      0.38        15\n",
            "         donut       0.17      0.46      0.24        13\n",
            "      elephant       0.57      1.00      0.72        25\n",
            "  fire hydrant       0.33      1.00      0.50         2\n",
            "          fork       0.15      1.00      0.26         9\n",
            "       frisbee       0.22      1.00      0.36         2\n",
            "       giraffe       0.36      0.91      0.52        23\n",
            "    hair drier       0.00      0.00      0.00         0\n",
            "       handbag       0.10      0.53      0.17        15\n",
            "         horse       0.24      0.88      0.37        17\n",
            "       hot dog       0.12      0.20      0.15         5\n",
            "      keyboard       0.00      0.00      0.00         0\n",
            "          kite       0.59      0.88      0.71       140\n",
            "         knife       0.11      0.78      0.19         9\n",
            "        laptop       0.19      0.75      0.30         4\n",
            "     microwave       0.33      1.00      0.50         1\n",
            "    motorcycle       0.64      1.00      0.78        41\n",
            "         mouse       0.00      0.00      0.00         0\n",
            "        orange       0.11      1.00      0.20         2\n",
            "          oven       0.04      1.00      0.07         2\n",
            " parking meter       0.00      0.00      0.00         1\n",
            "        person       0.52      0.94      0.67       716\n",
            "         pizza       0.18      0.78      0.29         9\n",
            "  potted plant       0.00      0.00      0.00         0\n",
            "  refrigerator       0.21      1.00      0.35         3\n",
            "        remote       0.00      0.00      0.00         0\n",
            "      sandwich       0.25      1.00      0.40         6\n",
            "      scissors       0.11      1.00      0.20         1\n",
            "         sheep       0.07      1.00      0.12         2\n",
            "          sink       0.03      0.60      0.06         5\n",
            "    skateboard       0.12      1.00      0.22         3\n",
            "          skis       0.15      1.00      0.27         8\n",
            "     snowboard       0.06      0.50      0.10         2\n",
            "         spoon       0.10      0.67      0.18         9\n",
            "   sports ball       0.27      1.00      0.43         3\n",
            "     stop sign       0.50      0.50      0.50         2\n",
            "      suitcase       0.11      0.22      0.15         9\n",
            "     surfboard       0.17      0.73      0.28        30\n",
            "    teddy bear       0.14      1.00      0.25         1\n",
            " tennis racket       0.12      1.00      0.22         2\n",
            "           tie       0.11      0.83      0.20         6\n",
            "       toaster       0.00      0.00      0.00         0\n",
            "        toilet       0.00      0.00      0.00         0\n",
            "    toothbrush       0.06      0.50      0.10         2\n",
            " traffic light       0.32      0.79      0.45        24\n",
            "         train       0.16      1.00      0.27         5\n",
            "         truck       0.15      0.68      0.24        19\n",
            "            tv       0.06      1.00      0.12         1\n",
            "      umbrella       0.42      0.85      0.56        34\n",
            "          vase       0.03      1.00      0.06         1\n",
            "    wine glass       0.06      0.50      0.11         4\n",
            "         zebra       0.56      1.00      0.72        14\n",
            "\n",
            "     micro avg       0.26      0.86      0.40      1735\n",
            "     macro avg       0.18      0.72      0.26      1735\n",
            "  weighted avg       0.41      0.86      0.53      1735\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also obtain more granular information by looking at performance on a sample-wise basis. For instance, we can sort the samples by the number of false positive detections and view this in the FiftyOne App:"
      ],
      "metadata": {
        "id": "O596ISDZSr6F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fp_view = (\n",
        "    dataset\n",
        "    .sort_by(\"eval_fp\", reverse=True)\n",
        "    .filter_labels(\"predictions\", F(\"eval\") == \"fp\")\n",
        ")\n",
        "\n",
        "session.view = fp_view.view()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "anfZD2ovS3yG",
        "outputId": "d28ff948-09f1-4020-d05a-5bc93dc65540"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "<style>\n",
              "\n",
              "@import url(\"https://fonts.googleapis.com/css2?family=Palanquin&display=swap\");\n",
              "\n",
              "body, html {\n",
              "  margin: 0;\n",
              "  padding: 0;\n",
              "  width: 100%;\n",
              "}\n",
              "\n",
              "#focontainer-229b6e1d-9e9e-4c6d-a67b-358021ed14b7 {\n",
              "  position: relative;\n",
              "  height: px;\n",
              "  display: block !important;\n",
              "}\n",
              "#foactivate-229b6e1d-9e9e-4c6d-a67b-358021ed14b7 {\n",
              "  font-weight: bold;\n",
              "  cursor: pointer;\n",
              "  font-size: 24px;\n",
              "  border-radius: 3px;\n",
              "  text-align: center;\n",
              "  padding: 0.5em;\n",
              "  color: rgb(255, 255, 255);\n",
              "  font-family: \"Palanquin\", sans-serif;\n",
              "  position: absolute;\n",
              "  left: 50%;\n",
              "  top: 50%;\n",
              "  width: 160px;\n",
              "  margin-left: -80px;\n",
              "  margin-top: -23px;\n",
              "  background: hsla(210,11%,15%, 0.8);\n",
              "  border: none;\n",
              "}\n",
              "#foactivate-229b6e1d-9e9e-4c6d-a67b-358021ed14b7:focus {\n",
              "  outline: none;\n",
              "}\n",
              "#fooverlay-229b6e1d-9e9e-4c6d-a67b-358021ed14b7 {\n",
              "  width: 100%;\n",
              "  height: 100%;\n",
              "  background: hsla(208, 7%, 46%, 0.7);\n",
              "  position: absolute;\n",
              "  top: 0;\n",
              "  left: 0;\n",
              "  display: none;\n",
              "  cursor: pointer;\n",
              "}\n",
              "</style>\n",
              "<div id=\"focontainer-229b6e1d-9e9e-4c6d-a67b-358021ed14b7\" style=\"display: none;\">\n",
              "   <div id=\"fooverlay-229b6e1d-9e9e-4c6d-a67b-358021ed14b7\">\n",
              "      <button id=\"foactivate-229b6e1d-9e9e-4c6d-a67b-358021ed14b7\" >Activate</button>\n",
              "   </div>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can plot PR curves or confusion matrices to see things from a different perspective:"
      ],
      "metadata": {
        "id": "_1u6XNXXTYGW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate a confusion matrix for the specified classes\n",
        "plot = eval_results.plot_confusion_matrix(classes=[\"car\", \"truck\", \"motorcycle\"])\n",
        "plot.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 666
        },
        "id": "5oSiQuN3Tfmv",
        "outputId": "6a302a37-8215-42d5-9ea5-0647442cd1f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/fiftyone/core/plots/plotly.py:1575: UserWarning:\n",
            "\n",
            "Interactive plots are currently only supported in Jupyter notebooks. Support outside of notebooks and in Google Colab will be included in an upcoming release. In the meantime, you can still use this plot, but note that (i) selecting data will not trigger callbacks, and (ii) you must manually call `plot.show()` to launch a new plot that reflects the current state of an attached session.\n",
            "\n",
            "See https://docs.voxel51.com/user_guide/plots.html#working-in-notebooks for more information.\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<html>\n",
              "<head><meta charset=\"utf-8\" /></head>\n",
              "<body>\n",
              "    <div>            <script src=\"https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-AMS-MML_SVG\"></script><script type=\"text/javascript\">if (window.MathJax) {MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}</script>                <script type=\"text/javascript\">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>\n",
              "        <script src=\"https://cdn.plot.ly/plotly-2.8.3.min.js\"></script>                <div id=\"4134ca39-4421-4446-a008-997d92988caa\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"4134ca39-4421-4446-a008-997d92988caa\")) {                    Plotly.newPlot(                        \"4134ca39-4421-4446-a008-997d92988caa\",                        [{\"mode\":\"markers\",\"opacity\":0.1,\"x\":[0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3],\"y\":[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3],\"type\":\"scatter\",\"uid\":\"c4b96259-209f-465b-b9ba-631fb4bacc84\"},{\"colorscale\":[[0.0,\"rgb(255,245,235)\"],[0.125,\"rgb(254,230,206)\"],[0.25,\"rgb(253,208,162)\"],[0.375,\"rgb(253,174,107)\"],[0.5,\"rgb(253,141,60)\"],[0.625,\"rgb(241,105,19)\"],[0.75,\"rgb(217,72,1)\"],[0.875,\"rgb(166,54,3)\"],[1.0,\"rgb(127,39,4)\"]],\"hoverinfo\":\"skip\",\"showscale\":false,\"z\":[[228,75,23,0],[0,0,41,0],[0,13,0,6],[49,0,0,12]],\"zmax\":228,\"zmin\":0,\"type\":\"heatmap\",\"uid\":\"c8a38b04-9b5a-418a-af84-165031530c45\"},{\"colorbar\":{\"len\":1,\"lenmode\":\"fraction\"},\"colorscale\":[[0.0,\"rgb(255,245,235)\"],[0.125,\"rgb(254,230,206)\"],[0.25,\"rgb(253,208,162)\"],[0.375,\"rgb(253,174,107)\"],[0.5,\"rgb(253,141,60)\"],[0.625,\"rgb(241,105,19)\"],[0.75,\"rgb(217,72,1)\"],[0.875,\"rgb(166,54,3)\"],[1.0,\"rgb(127,39,4)\"]],\"hovertemplate\":\"<b>count: %{z}</b><br>truth: %{y}<br>predicted: %{x}<extra></extra>\",\"opacity\":0.25,\"z\":[[228,75,23,0],[0,0,41,0],[0,13,0,6],[49,0,0,12]],\"zmax\":228,\"zmin\":0,\"type\":\"heatmap\",\"uid\":\"772bca46-b5f1-4a09-9228-04f9c26134ea\"}],                        {\"clickmode\":\"event\",\"template\":{\"data\":{\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"rgb(237,237,237)\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"bar\":[{\"error_x\":{\"color\":\"rgb(51,51,51)\"},\"error_y\":{\"color\":\"rgb(51,51,51)\"},\"marker\":{\"line\":{\"color\":\"rgb(237,237,237)\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"rgb(51,51,51)\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"rgb(51,51,51)\"},\"baxis\":{\"endlinecolor\":\"rgb(51,51,51)\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"rgb(51,51,51)\"},\"type\":\"carpet\"}],\"choropleth\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"type\":\"choropleth\"}],\"contourcarpet\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"type\":\"contourcarpet\"}],\"contour\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"contour\"}],\"heatmapgl\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"heatmapgl\"}],\"heatmap\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"heatmap\"}],\"histogram2dcontour\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"histogram2dcontour\"}],\"histogram2d\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"histogram2d\"}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"mesh3d\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"type\":\"mesh3d\"}],\"parcoords\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"parcoords\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}],\"scatter3d\":[{\"line\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scatter3d\"}],\"scattercarpet\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scattercarpet\"}],\"scattergeo\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scattergeo\"}],\"scattergl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scattergl\"}],\"scattermapbox\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scattermapbox\"}],\"scatterpolargl\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scatterpolargl\"}],\"scatterpolar\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scatterpolar\"}],\"scatter\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scatter\"}],\"scatterternary\":[{\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"type\":\"scatterternary\"}],\"surface\":[{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"},\"colorscale\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"type\":\"surface\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"rgb(237,237,237)\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"rgb(217,217,217)\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}]},\"layout\":{\"annotationdefaults\":{\"arrowhead\":0,\"arrowwidth\":1},\"autotypenumbers\":\"strict\",\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"tickcolor\":\"rgb(237,237,237)\",\"ticklen\":6,\"ticks\":\"inside\"}},\"colorscale\":{\"sequential\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]],\"sequentialminus\":[[0,\"rgb(20,44,66)\"],[1,\"rgb(90,179,244)\"]]},\"colorway\":[\"#F8766D\",\"#A3A500\",\"#00BF7D\",\"#00B0F6\",\"#E76BF3\"],\"font\":{\"color\":\"rgb(51,51,51)\"},\"geo\":{\"bgcolor\":\"white\",\"lakecolor\":\"white\",\"landcolor\":\"rgb(237,237,237)\",\"showlakes\":true,\"showland\":true,\"subunitcolor\":\"white\"},\"hoverlabel\":{\"align\":\"left\"},\"hovermode\":\"closest\",\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"rgb(237,237,237)\",\"polar\":{\"angularaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\"},\"bgcolor\":\"rgb(237,237,237)\",\"radialaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\"}},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"rgb(237,237,237)\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\",\"zerolinecolor\":\"white\"},\"yaxis\":{\"backgroundcolor\":\"rgb(237,237,237)\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\",\"zerolinecolor\":\"white\"},\"zaxis\":{\"backgroundcolor\":\"rgb(237,237,237)\",\"gridcolor\":\"white\",\"gridwidth\":2,\"linecolor\":\"white\",\"showbackground\":true,\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\",\"zerolinecolor\":\"white\"}},\"shapedefaults\":{\"fillcolor\":\"black\",\"line\":{\"width\":0},\"opacity\":0.3},\"ternary\":{\"aaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\"},\"baxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\"},\"bgcolor\":\"rgb(237,237,237)\",\"caxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\"}},\"xaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\"},\"yaxis\":{\"automargin\":true,\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showgrid\":true,\"tickcolor\":\"rgb(51,51,51)\",\"ticks\":\"outside\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\"}}},\"xaxis\":{\"constrain\":\"domain\",\"range\":[-0.5,3.5],\"tickmode\":\"array\",\"ticktext\":[\"car\",\"truck\",\"motorcycle\",\"(none)\"],\"tickvals\":[0,1,2,3]},\"yaxis\":{\"constrain\":\"domain\",\"range\":[-0.5,3.5],\"scaleanchor\":\"x\",\"scaleratio\":1,\"tickmode\":\"array\",\"ticktext\":[\"(none)\",\"motorcycle\",\"truck\",\"car\"],\"tickvals\":[0,1,2,3]},\"margin\":{\"r\":0,\"t\":30,\"l\":0,\"b\":0},\"title\":{}},                        {\"responsive\": true}                    ).then(function(){\n",
              "                            \n",
              "var gd = document.getElementById('4134ca39-4421-4446-a008-997d92988caa');\n",
              "var x = new MutationObserver(function (mutations, observer) {{\n",
              "        var display = window.getComputedStyle(gd).display;\n",
              "        if (!display || display === 'none') {{\n",
              "            console.log([gd, 'removed!']);\n",
              "            Plotly.purge(gd);\n",
              "            observer.disconnect();\n",
              "        }}\n",
              "}});\n",
              "\n",
              "// Listen for the removal of the full notebook cells\n",
              "var notebookContainer = gd.closest('#notebook-container');\n",
              "if (notebookContainer) {{\n",
              "    x.observe(notebookContainer, {childList: true});\n",
              "}}\n",
              "\n",
              "// Listen for the clearing of the current output cell\n",
              "var outputEl = gd.closest('.output');\n",
              "if (outputEl) {{\n",
              "    x.observe(outputEl, {childList: true});\n",
              "}}\n",
              "\n",
              "                        })                };                            </script>        </div>\n",
              "</body>\n",
              "</html>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lastly, we can view predictions on a patch-by-patch basis:"
      ],
      "metadata": {
        "id": "Xx1HgdLu9Eno"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "eval_patches_view = dataset.to_evaluation_patches(\"eval\")\n",
        "session.view = eval_patches_view"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "ZIr6D0LmT279",
        "outputId": "3b36ab25-7387-49b6-9471-71a3dafa3615"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "<style>\n",
              "\n",
              "@import url(\"https://fonts.googleapis.com/css2?family=Palanquin&display=swap\");\n",
              "\n",
              "body, html {\n",
              "  margin: 0;\n",
              "  padding: 0;\n",
              "  width: 100%;\n",
              "}\n",
              "\n",
              "#focontainer-7bf3efc3-0f46-482a-9a0d-ac5596e75f51 {\n",
              "  position: relative;\n",
              "  height: px;\n",
              "  display: block !important;\n",
              "}\n",
              "#foactivate-7bf3efc3-0f46-482a-9a0d-ac5596e75f51 {\n",
              "  font-weight: bold;\n",
              "  cursor: pointer;\n",
              "  font-size: 24px;\n",
              "  border-radius: 3px;\n",
              "  text-align: center;\n",
              "  padding: 0.5em;\n",
              "  color: rgb(255, 255, 255);\n",
              "  font-family: \"Palanquin\", sans-serif;\n",
              "  position: absolute;\n",
              "  left: 50%;\n",
              "  top: 50%;\n",
              "  width: 160px;\n",
              "  margin-left: -80px;\n",
              "  margin-top: -23px;\n",
              "  background: hsla(210,11%,15%, 0.8);\n",
              "  border: none;\n",
              "}\n",
              "#foactivate-7bf3efc3-0f46-482a-9a0d-ac5596e75f51:focus {\n",
              "  outline: none;\n",
              "}\n",
              "#fooverlay-7bf3efc3-0f46-482a-9a0d-ac5596e75f51 {\n",
              "  width: 100%;\n",
              "  height: 100%;\n",
              "  background: hsla(208, 7%, 46%, 0.7);\n",
              "  position: absolute;\n",
              "  top: 0;\n",
              "  left: 0;\n",
              "  display: none;\n",
              "  cursor: pointer;\n",
              "}\n",
              "</style>\n",
              "<div id=\"focontainer-7bf3efc3-0f46-482a-9a0d-ac5596e75f51\" style=\"display: none;\">\n",
              "   <div id=\"fooverlay-7bf3efc3-0f46-482a-9a0d-ac5596e75f51\">\n",
              "      <button id=\"foactivate-7bf3efc3-0f46-482a-9a0d-ac5596e75f51\" >Activate</button>\n",
              "   </div>\n",
              "</div>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saving our findings"
      ],
      "metadata": {
        "id": "L7OZHw9S976H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we are satisfied with our exploration for the moment, and we would like to save our finding so that we can pick things up later on, we can save the dataset by making it persistent, as well as any interesting views we have found - saving views from Python works in just the same way as saving views in the App!"
      ],
      "metadata": {
        "id": "hkRBe1sN-Ad7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset.persistent = True\n",
        "dataset.save_view(\"eval_patches\", eval_patches_view)\n",
        "dataset.save_view(\"fp_view\", fp_view)"
      ],
      "metadata": {
        "id": "ODOlGNVEUidW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conclusion"
      ],
      "metadata": {
        "id": "i4iKD8A3cHox"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Action Items"
      ],
      "metadata": {
        "id": "ZsInKLxldzSu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   If you like FiftyOne and enjoyed today's workshop, give us a [star on GitHub](https://github.com/voxel51/fiftyone).\n",
        "*   [Join the FiftyOne Slack Community](https://join.slack.com/t/fiftyone-users/shared_invite/zt-1q38aprwl-CNQUoFGZ9tX3ypekmbRk8A). It's the place to be if you have any questions about FiftyOne.\n",
        "*   If you're part of a data science, data engineering, machine learning, or computer vision, check out [FiftyOne Teams](https://docs.voxel51.com/teams/index.html)!\n",
        "\n"
      ],
      "metadata": {
        "id": "yCzRC7bAd9FY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Resources"
      ],
      "metadata": {
        "id": "tN7eye-Ad9UV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you're interested in diving deeper into FiftyOne, check out the [FiftyOne Docs](https://docs.voxel51.com/). We've got everything from [tutorials](https://docs.voxel51.com/tutorials/index.html) and [blog posts](https://voxel51.com/blog/) to [cheat sheets](https://docs.voxel51.com/cheat_sheets/index.html) and [code recipes](https://docs.voxel51.com/recipes/index.html).\n",
        "\n",
        "A few resourcs which you might find especially helpful are:\n",
        "\n",
        "\n",
        "*   [Using the FiftyOne App](https://docs.voxel51.com/user_guide/app.html)\n",
        "*   [Performing pandas-style queries in FiftyOne](https://docs.voxel51.com/tutorials/pandas_comparison.html)\n",
        "*   [View stages cheat sheet](https://docs.voxel51.com/cheat_sheets/views_cheat_sheet.html)\n",
        "*   [Filtering cheat sheet](https://docs.voxel51.com/cheat_sheets/filtering_cheat_sheet.html)\n",
        "*   [Loading](https://docs.voxel51.com/user_guide/dataset_creation/index.html) and [exporting datasets](https://docs.voxel51.com/user_guide/export_datasets.html)\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "8WY_JpObd9ci"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Next Steps"
      ],
      "metadata": {
        "id": "JTNFEGUAf5RO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "*   Explore datasets in the [FiftyOne Dataset Zoo](https://docs.voxel51.com/user_guide/dataset_zoo/index.html)\n",
        "*   Load a model from the [FiftyOne Model Zoo](https://docs.voxel51.com/user_guide/model_zoo/index.html) and use it to add predictions to a dataset.\n",
        "*   [Import your own data into FiftyOne](https://docs.voxel51.com/user_guide/dataset_creation/index.html)\n",
        "*   [Compute and visualize embeddings](https://docs.voxel51.com/tutorials/qdrant.html) on your dataset\n",
        "*   Send a labeling job to [CVAT](https://docs.voxel51.com/tutorials/cvat_annotation.html), [Labelbox](https://docs.voxel51.com/tutorials/labelbox_annotation.html), or [Label Studio](https://docs.voxel51.com/integrations/labelstudio.html) via our integrations\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "PVJXimG2o_Je"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uLNio2PfqIuN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3gmF9iFB4tC4"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}