\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Evaluating PyTorchVideo models with FiftyOne\n",
"\n",
"[PyTorchVideo](https://pytorchvideo.org/) is a new library that intends to make it just as easy to load and build video-based deep models as image models. They provide access to a video model zoo, video data processing functions, and a video-focused accelerator to deploy models all backed in PyThon allowing seamless integration into existing workflows.\n",
"\n",
"The only thing missing from PyTorchVideo to complete your video workflows is a way to visualize your datasets and interpret your model results. This is where [FiftyOne](http://fiftyone.ai/) comes in. FiftyOne is an open-source tool designed to make it easy to load in and visualize any image or video dataset along with ground truth and predicted labels. The flexible representation of [FiftyOne datasets](https://voxel51.com/docs/fiftyone/user_guide/basics.html) and the [FiftyOne App](https://voxel51.com/docs/fiftyone/user_guide/app.html) let you quickly get hands-on with your datasets and interpret your model to find failure modes, annotation mistakes, visualize complex labels, and much more.\n",
"\n",
"In this walkthrough, we will cover:\n",
"\n",
"- Downloading a subset of the [Kinetics dataset](https://deepmind.com/research/open-source/kinetics)\n",
"- Loading a [video dataset in FiftyOne](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/datasets.html#videoclassificationdirectorytree-import)\n",
"- Using [PyTorchVideo to perform inference](https://pytorchvideo.org/docs/tutorial_torchhub_inference) on a FiftyOne dataset\n",
"- Visualizing and [evaluating the PyTorchVideo model using FiftyOne](https://voxel51.com/docs/fiftyone/tutorials/evaluate_classifications.html)\n",
"\n",
"\n",
"**So, what's the takeaway?**\n",
"\n",
"Visualizing computer vision datasets is hard, especially for video data. Exploring datasets containing tens of thousands of samples with complex label types like detections or segmentations either requires significant custom scripting or is just skipped altogether. However, if you don't visualize, explore, and understand your dataset and model results, then you create an artificial ceiling for your model's performance.\n",
"\n",
"FiftyOne allows you to easily view, explore, and evaluate image and video models and datasets. When paired with the new PyTorchVideo library, video-based ML workflows are now more efficient and thorough than ever before."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup\n",
"\n",
"*This walkthrough requires Python 3.7 or 3.8 for PyTorchVideo*\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install fiftyone"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install torch torchvision"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note: For this walkthrough, PyTorchVideo needs to be [installed through GitHub](https://github.com/facebookresearch/pytorchvideo). Though otherwise it can be installed with:\n",
"```pip install pytorchvideo```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!git clone https://github.com/facebookresearch/pytorchvideo.git\n",
"%cd pytorchvideo\n",
"!pip install -e .\n",
"%cd .."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will also be using a TensorFlow 1.14 model later in this walkthrough:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install tensorflow==1.14"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**If you are running this is Google Colab** you will need to restart the runtime by uncommenting and running following command before running any other running cells. This is required to properly install PyTorchVideo from GitHub and a new version of TensorFlow in Colab."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# exit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This tutorial also includes some of FiftyOne’s [interactive plotting capabilities](https://voxel51.com/docs/fiftyone/user_guide/plots.html).\n",
"\n",
"The recommended way to work with FiftyOne’s interactive plots is in [Jupyter notebooks](https://jupyter.org/) or [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/). In these environments, you can leverage the full power of plots by [attaching them to the FiftyOne App](https://voxel51.com/docs/fiftyone/user_guide/plots.html#attaching-plots) and bidirectionally interacting with the plots and the App to identify interesting subsets of your data.\n",
"\n",
"To use interactive plots in Jupyter notebooks, ensure that you have the ipywidgets package installed:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install ipywidgets>=7.5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you’re working in JupyterLab, refer to [these instructions](https://voxel51.com/docs/fiftyone/user_guide/plots.html#working-in-notebooks) to get setup.\n",
"\n",
"*Support for interactive plots in non-notebook contexts and Google Colab is coming soon! In the meantime, you can still use FiftyOne’s plotting features in those environments, but you must manually call plot.show() to update the state of a plot to match the state of a connected session, and any callbacks that would normally be triggered in response to interacting with a plot will not be triggered.*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Prepare data\n",
"\n",
"In this walkthrough, we are using a subset of the [Kinetics 400 action recognition dataset](https://deepmind.com/research/open-source/kinetics) composed of 400 human activity classes over 600,000 10-second long video clips sources from YouTube.\n",
"\n",
"We will first need to download the labels for Kinetics as well as [youtube-dl](http://ytdl-org.github.io/youtube-dl/download.html) which we will use to download the video data from YouTube."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!pip install youtube-dl"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!wget https://storage.googleapis.com/deepmind-media/Datasets/kinetics400.tar.gz\n",
"!tar -xvf ./kinetics400.tar.gz"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Finished downloading videos!"
]
}
],
"source": [
"from datetime import timedelta\n",
"import json\n",
"import os\n",
"import subprocess\n",
"\n",
"import youtube_dl\n",
"from youtube_dl.utils import (DownloadError, ExtractorError)\n",
"\n",
"def download_video(url, start, dur, output):\n",
" output_tmp = os.path.join(\"/tmp\",os.path.basename(output))\n",
" try:\n",
" # From https://stackoverflow.com/questions/57131049/is-it-possible-to-download-a-specific-part-of-a-file\n",
" with youtube_dl.YoutubeDL({'format': 'best'}) as ydl:\n",
" result = ydl.extract_info(url, download=False)\n",
" video = result['entries'][0] if 'entries' in result else result\n",
" \n",
" url = video['url']\n",
" if start < 5:\n",
" offset = start\n",
" else:\n",
" offset = 5\n",
" start -= offset\n",
" offset_dur = dur + offset\n",
" start_str = str(timedelta(seconds=start)) \n",
" dur_str = str(timedelta(seconds=offset_dur)) \n",
"\n",
" cmd = ['ffmpeg', '-i', url, '-ss', start_str, '-t', dur_str, '-c:v',\n",
" 'copy', '-c:a', 'copy', output_tmp]\n",
" subprocess.call(cmd)\n",
"\n",
" start_str_2 = str(timedelta(seconds=offset)) \n",
" dur_str_2 = str(timedelta(seconds=dur)) \n",
"\n",
" cmd = ['ffmpeg', '-i', output_tmp, '-ss', start_str_2, '-t', dur_str_2, output]\n",
" subprocess.call(cmd)\n",
" return True\n",
" \n",
" except (DownloadError, ExtractorError) as e:\n",
" print(\"Failed to download %s\" % output)\n",
" return False\n",
" \n",
"with open(\"./kinetics400/test.json\", \"r\") as f:\n",
" test_data = json.load(f)\n",
"\n",
"target_classes = [\n",
" 'springboard diving',\n",
" 'surfing water',\n",
" 'swimming backstroke',\n",
" 'swimming breast stroke',\n",
" 'swimming butterfly stroke',\n",
"]\n",
"data_dir = \"./videos\"\n",
"max_samples = 5\n",
" \n",
"classes_count = {c:0 for c in target_classes}\n",
"\n",
"for fn, data in test_data.items():\n",
" label = data[\"annotations\"][\"label\"]\n",
" segment = data[\"annotations\"][\"segment\"]\n",
" url = data[\"url\"]\n",
" dur = data[\"duration\"]\n",
" if label in classes_count and classes_count[label] < max_samples:\n",
" c_dir = os.path.join(data_dir, label)\n",
" if not os.path.exists(c_dir):\n",
" os.makedirs(c_dir)\n",
" \n",
"\n",
" start = segment[0]\n",
" output = os.path.join(c_dir, \"%s_%s.mp4\" % (label.replace(\" \",\"_\"), fn))\n",
" \n",
" results = True\n",
" if not os.path.exists(output):\n",
" result = download_video(url, start, dur, output)\n",
" if result:\n",
" classes_count[label] += 1\n",
"\n",
"print(\"Finished downloading videos!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load dataset in FiftyOne\n",
"\n",
"FiftyOne is designed to make it as easy as possible to [load and visualize your image and video datasets](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/index.html) even with complex label types like detections and segmentations.\n",
"\n",
"If your dataset follows a common format, like the [COCO format for detections](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/datasets.html#cocodetectiondataset-import), then you can load it in a single line of code. Even if you use a [custom format](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/samples.html), you can always easily load your labels manually.\n",
"\n",
"In this example, we will be following the [PyTorchVision tutorial](https://pytorchvideo.org/docs/tutorial_torchhub_inference) on running a video classification model. Generally, video classification datasets will be [stored on disk in a directory tree](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/datasets.html#videoclassificationdirectorytree-import) whose subfolders define dataset classes. This format can be loaded in one line of code:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import fiftyone as fo"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 100% |███████████████████| 25/25 [288.2ms elapsed, 0s remaining, 86.8 samples/s] \n"
]
}
],
"source": [
"name = \"kinetics-subset\"\n",
"dataset_dir = \"./videos\"\n",
"\n",
"# Create the dataset\n",
"dataset = fo.Dataset.from_dir(\n",
" dataset_dir, fo.types.VideoClassificationDirectoryTree, name=name\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's launch the [FiftyOne App](https://voxel51.com/docs/fiftyone/user_guide/app.html) and look at the data we loaded. Hover over or click on the samples to play the videos."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Launch the App and view the dataset\n",
"session = fo.launch_app(dataset)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"session.freeze()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"FiftyOne datasets also allow you to [store a list of default class names](https://voxel51.com/docs/fiftyone/user_guide/using_datasets.html#storing-class-lists) that will be used when evaluating predictions."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!wget https://dl.fbaipublicfiles.com/pyslowfast/dataset/class_names/kinetics_classnames.json"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"import json"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"with open(\"kinetics_classnames.json\", \"r\") as f:\n",
" kinetics_classnames = json.load(f)\n",
"\n",
"# Sort and format classes\n",
"dataset.default_classes = sorted([c.replace('\"','') for c in kinetics_classnames.keys()])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Running a PyTorchVideo model\n",
"\n",
"In this section, we use PyTorchVideo download and run a video classification model on the data that we previously loaded and store the results in FiftyOne.\n",
"\n",
"[Torch Hub](https://pytorch.org/hub/) is a repository for pretrained PyTorch models that allow you to easily download and run inference on your dataset. PyTorchVideo provides a number of video classification models through their [Torch Hub-backed model zoo](https://pytorchvideo.readthedocs.io/en/latest/model_zoo.html) including SlowFast, I3D, C2D, R(2+1)D, and X3D. The following downloads the slow branch of SlowFast with a ResNet50 backbone and loads it into Python:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"import json\n",
"import torch\n",
"from torchvision.transforms import Compose, Lambda\n",
"from torchvision.transforms._transforms_video import (\n",
" CenterCropVideo,\n",
" NormalizeVideo,\n",
")\n",
"from pytorchvideo.transforms import (\n",
" ApplyTransformToKey,\n",
" ShortSideScale,\n",
" UniformTemporalSubsample\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Device on which to run the model\n",
"#device = \"cuda:0\"\n",
"device = \"cpu\"\n",
"\n",
"# Pick a pretrained model\n",
"model_name = \"slow_r50\"\n",
"\n",
"# Local path to the parent folder of hubconf.py in the pytorchvideo codebase\n",
"path = 'pytorchvideo'\n",
"model = torch.hub.load(path, source=\"local\", model=model_name, pretrained=False)\n",
"\n",
"model_url = \"https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOW_8x8_R50.pyth\"\n",
"\n",
"checkpoint = torch.hub.load_state_dict_from_url(model_url, map_location=device)\n",
"state_dict = checkpoint[\"model_state\"]\n",
"\n",
"# Apply the state dict to the model\n",
"model.load_state_dict(state_dict)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"# Set to eval mode and move to desired device\n",
"model = model.eval()\n",
"model = model.to(device)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# Create an id to label name mapping\n",
"kinetics_id_to_classname = {v:k for v,k in enumerate(dataset.default_classes)}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Every model has a specific input that it expects. The standard workflow is to write custom scripts that perform the necessary loading and transformation functions to format data for every model. PyTorchVision makes this process easier by [providing these functions](https://pytorchvideo.readthedocs.io/en/latest/transforms.html) for you in a flexible way that will work for most video processing needs. For example, the following code constructs the PyTorch transforms to sample frames from the video, normalize, scale, and crop it, without needing to write any of those functions yourself:\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"side_size = 256\n",
"mean = [0.45, 0.45, 0.45]\n",
"std = [0.225, 0.225, 0.225]\n",
"crop_size = 256\n",
"num_frames = 8"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# Note that this transform is specific to the slow_R50 model.\n",
"# If you want to try another of the torch hub models you will need to modify this transform\n",
"transform = ApplyTransformToKey(\n",
" key=\"video\",\n",
" transform=Compose(\n",
" [\n",
" UniformTemporalSubsample(num_frames),\n",
" Lambda(lambda x: x/255.0),\n",
" NormalizeVideo(mean, std),\n",
" ShortSideScale(\n",
" size=side_size\n",
" ),\n",
" CenterCropVideo(crop_size=(crop_size, crop_size))\n",
" ]\n",
" ),\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Since the dataset is being stored in FiftyOne, we can easily iterate through the samples, load and run our model on them with PyTorchVideo, and store the predictions back in FiftyOne for further visualization and analysis:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"from pytorchvideo.data.encoded_video import EncodedVideo"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"import fiftyone.core.utils as fouo"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def parse_predictions(preds, kinetics_id_to_classname, k=5):\n",
" preds_topk = preds.topk(k=k)\n",
" pred_classes = preds_topk.indices[0]\n",
" pred_scores = preds_topk.values[0]\n",
"\n",
" preds_top1 = preds.topk(k=1)\n",
" pred_class = preds_top1.indices[0]\n",
" pred_score = preds_top1.values[0]\n",
" \n",
" # Map the predicted classes to the label names\n",
" pred_class_names = [kinetics_id_to_classname[int(i)] for i in pred_classes]\n",
" pred_class_name = kinetics_id_to_classname[int(pred_class)]\n",
" \n",
" prediction_top_1 = fo.Classification(\n",
" label=pred_class_name,\n",
" confidence=pred_score,\n",
" )\n",
" predictions_top_k = []\n",
" \n",
" for l, c in zip(pred_class_names, pred_scores):\n",
" cls = fo.Classification(label=l, confidence=c)\n",
" predictions_top_k.append(cls)\n",
" \n",
" predictions_top_k = fo.Classifications(classifications=predictions_top_k)\n",
" \n",
" return prediction_top_1, predictions_top_k"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 100% |███████████████████| 25/25 [4.0m elapsed, 0s remaining, 0.1 samples/s] \n"
]
}
],
"source": [
"with torch.no_grad():\n",
" with fouo.ProgressBar() as pb:\n",
" for sample in pb(dataset):\n",
" video_path = sample.filepath\n",
"\n",
" # Initialize an EncodedVideo helper class\n",
" video = EncodedVideo.from_path(video_path)\n",
"\n",
" # Select the duration of the clip to load by specifying the start and end duration\n",
" # The start_sec should correspond to where the action occurs in the video\n",
" start_sec = 0\n",
" clip_duration = int(video.duration)\n",
" end_sec = start_sec + clip_duration \n",
"\n",
" # Load the desired clip\n",
" video_data = video.get_clip(start_sec=start_sec, end_sec=end_sec)\n",
"\n",
" # Apply a transform to normalize the video input\n",
" video_data = transform(video_data)\n",
"\n",
" # Move the inputs to the desired device\n",
" inputs = video_data[\"video\"]\n",
" inputs = inputs.to(device)\n",
"\n",
" # Pass the input clip through the model\n",
" preds_pre_act = model(inputs[None, ...])\n",
"\n",
" # Get the predicted classes\n",
" post_act = torch.nn.Softmax(dim=1)\n",
" preds = post_act(preds_pre_act)\n",
"\n",
" # Generate FiftyOne labels from predictions\n",
" prediction_top_1, predictions_top_5 = parse_predictions(preds, kinetics_id_to_classname, k=5)\n",
"\n",
" # Add FiftyOne label fields to Sample\n",
" sample[\"predictions\"] = prediction_top_1\n",
" sample[\"predictions_top_5\"] = predictions_top_5\n",
" sample.save()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now see that the [fields](https://voxel51.com/docs/fiftyone/user_guide/using_datasets.html#fields) `predictions` and `predictions_top_5` have been added to our dataset."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Name: kinetics-subset\n",
"Media type: video\n",
"Num samples: 25\n",
"Persistent: True\n",
"Tags: []\n",
"Sample fields:\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.Metadata)\n",
" ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Classification)\n",
" predictions: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Classification)\n",
" predictions_top_5: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Classifications)\n",
"Frame fields:\n",
" frame_number: fiftyone.core.fields.FrameNumberField\n"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dataset"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluating a model with FiftyOne\n",
"\n",
"Aside from being an open-source ecosystem for dataset curation, FiftyOne is also designed to visualize, evaluate, and interpret models by allowing you to quickly [find and address model failure modes](https://voxel51.com/docs/fiftyone/tutorials/evaluate_classifications.html).\n",
"\n",
"To this end, we can start by visualizing the predictions generated in the last section in FiftyOne:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"session = fo.launch_app(dataset)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [],
"source": [
"session.freeze()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can then use [FiftyOne to evaluate](https://voxel51.com/docs/fiftyone/user_guide/evaluation.html) the predictions with the ground truth to view aggregate metrics and plots showing things like [confusion matrices](https://voxel51.com/docs/fiftyone/user_guide/evaluation.html#confusion-matrices) and [precision-recall curves](https://voxel51.com/docs/fiftyone/user_guide/evaluation.html#binary-evaluation). Evaluation can be performed in just a single line of code:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"results = dataset.evaluate_classifications(\"predictions\", \"ground_truth\", eval_key=\"eval\")"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" springboard diving 0.80 0.80 0.80 5\n",
" surfing water 1.00 0.60 0.75 5\n",
" swimming backstroke 1.00 0.80 0.89 5\n",
" swimming breast stroke 0.57 0.80 0.67 5\n",
"swimming butterfly stroke 1.00 0.60 0.75 5\n",
"\n",
" micro avg 0.82 0.72 0.77 25\n",
" macro avg 0.87 0.72 0.77 25\n",
" weighted avg 0.87 0.72 0.77 25\n",
"\n"
]
}
],
"source": [
"target_classes = [\n",
" 'springboard diving',\n",
" 'surfing water',\n",
" 'swimming backstroke',\n",
" 'swimming breast stroke',\n",
" 'swimming butterfly stroke',\n",
"]\n",
"results.print_report(classes=target_classes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's plot the confusion matrix for the classes we are interested in:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot = results.plot_confusion_matrix(classes=target_classes)\n",
"plot.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can attach this plot to a session object to make it [interactive](https://voxel51.com/docs/fiftyone/user_guide/plots.html). So if you click one of the cells, the FiftyOne App session updates to show the samples in that cell."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot = results.plot_confusion_matrix(classes=target_classes)\n",
"plot.show()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"session = fo.launch_app(dataset)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# If you are in a Jupyter notebook, attach plot to session\n",
"session.plots.attach(plot)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Note: Plots are currently only interactive in Jupyter Notebooks but additional environments will be supported soon!*"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"session.freeze() # screenshot App and attached plots"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"FiftyOne also provides a novel query language to [create views](https://voxel51.com/docs/fiftyone/user_guide/using_views.html) into your dataset by [searching and filtering](https://voxel51.com/docs/fiftyone/user_guide/using_views.html#filtering) any given labels and metadata. This makes it easy to explore your dataset and find samples related to any question you may have in mind. For example, we can quickly find samples where the model was least certain about its prediction based on similar confidences across multiple classes:"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"from fiftyone import ViewField as F\n",
"\n",
"false_view = (\n",
" dataset\n",
" .sort_by(\n",
" F(\"predictions_top_5.classifications.confidence\").std(),\n",
" )\n",
" .match(F(\"eval\") == False)\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Visualizing these samples lets us get an idea of the type of data that should be added to the training dataset or presented more often in the training pipeline:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"scrolled": false
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"session = fo.launch_app(view=false_view)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [],
"source": [
"session.freeze() # screenshot App"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can tag these using the [tagging functionality in the FiftyOne App](https://voxel51.com/docs/fiftyone/user_guide/app.html#tags-and-tagging) so that we can easily refer to them later:"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"session = fo.launch_app(view=false_view)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [],
"source": [
"session.freeze() # screenshot App"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The ease of this hands-on analysis will generally lead to significant improvements in dataset quality, and consequently improvements in model performance, faster than any analysis only using aggregate dataset statistics."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Object detection in video\n",
"\n",
"While most large video datasets and research efforts revolve around classification problems like human activity recognition, applications of video-based ML are often centered more around object detection. At the moment, PyTorchVideo primarily supports video classification problems, however, there are video object detection capabilities available in FiftyOne.\n",
"\n",
"FiftyOne allows you to either generate predictions from an image-based object detection model in the [FiftyOne Model Zoo](https://voxel51.com/docs/fiftyone/user_guide/model_zoo/index.html#basic-recipe) or [add predictions from your own model](https://voxel51.com/docs/fiftyone/recipes/adding_detections.html) to a video dataset. In this example, let's use [EfficientDet-D0](https://voxel51.com/docs/fiftyone/user_guide/model_zoo/models.html#efficientdet-d0-coco-tf1), a detection model backed by [TensorFlow](https://www.tensorflow.org/) and [AutoML](https://github.com/google/automl). We can use [eta](https://github.com/voxel51/eta), a package installed with FiftyOne, to install AutoML."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"!eta install automl"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Applying a zoo model only requires a few lines of code:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import fiftyone.zoo as foz"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this example, we will be loading an image-based object detector and running it frame-wise on our video dataset."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"model = foz.load_zoo_model(\"efficientdet-d0-coco-tf1\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's take one springboard diving video and run the detector on every frame of the video."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"subset = dataset.take(1, seed=51)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" 100% |█████████████████| 270/270 [1.8m elapsed, 0s remaining, 2.8 samples/s] \n"
]
}
],
"source": [
"subset.apply_model(model, \"detections\")"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"
\n",
"
\n",
" \n",
"
\n",
" \n",
"
\n",
"\n",
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"session = fo.launch_app(view=subset)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"session.freeze()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This kind of visualization would require writing custom scripts to load the raw video, annotations, and predictions, then using something like [OpenCV](https://opencv.org/) to draw boxes and export the visualizations to a new video on disk. Then if you want to change the labels you are looking at you would need to rewrite your script and regenerate the videos every time. Instead, all of this took us only a few lines of code and resulted in an easier-to-use and more flexible representation of our data."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Summary\n",
"\n",
"This walkthrough an example of integrating PyTorchVideo with FiftyOne. Specifically, we covered:\n",
"\n",
"- Downloading a subset of the [Kinetics dataset](https://deepmind.com/research/open-source/kinetics)\n",
"- Loading a [video dataset in FiftyOne](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/datasets.html#videoclassificationdirectorytree-import)\n",
"- Using [PyTorchVideo to perform inference](https://pytorchvideo.org/docs/tutorial_torchhub_inference) on a FiftyOne dataset\n",
"- Visualizing and [evaluating the PyTorchVideo model using FiftyOne](https://voxel51.com/docs/fiftyone/tutorials/evaluate_classifications.html)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**So, what's the takeaway?**\n",
"\n",
"Video-based machine learning models are growing in popularity but have lacked the same level of ease-of-use code bases that allow for quick development and evaluation of image models. [PyTorchVideo](https://pytorchvideo.org/) aims to make it easier to implement, train, and evaluate video models through their model zoo, video-focused components, and acceleration functions. On the flip side, where PyTorchVideo is making it easier to work with video models, [FiftyOne](http://fiftyone.ai/) is an open-source library that aims to make it easy and efficient to curate, evaluate, and improve video (and image) datasets. Together, FiftyOne and PyTorchVideo provide significant savings in the time and effort required to create high-quality video datasets and models."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
![](\"https://user-images.githubusercontent.com/25985824/104791629-6e618700-5769-11eb-857f-d176b37d2496.png\")
\n",
" Try in Google Colab\n",
" \n",
" ![](\"https://user-images.githubusercontent.com/25985824/104791634-6efa1d80-5769-11eb-8a4c-71d6cb53ccf0.png\")
\n",
" Share via nbviewer\n",
" \n",
" ![](\"https://user-images.githubusercontent.com/25985824/104791633-6efa1d80-5769-11eb-8ee3-4b2123fe4b66.png\")
\n",
" View on GitHub\n",
" \n",
" ![](\"https://user-images.githubusercontent.com/25985824/104792428-60f9cc00-576c-11eb-95a4-5709d803023a.png\")
\n",
" Download notebook\n",
" \n",
" 
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"
\n",
"