{ "cells": [ { "cell_type": "markdown", "id": "direct-paragraph", "metadata": {}, "source": [ "\n", "\n", " \n", " \n", " \n", " \n", "
\n", " \n", " \n", " Try in Google Colab\n", " \n", " \n", " \n", " \n", " Share via nbviewer\n", " \n", " \n", " \n", " \n", " View on GitHub\n", " \n", " \n", " \n", " \n", " Download notebook\n", " \n", "
\n" ] }, { "cell_type": "markdown", "id": "close-brave", "metadata": {}, "source": [ "# How to Train Your Dragon (Detector)\n", "\n", "Often thought to be the stuff of legends, we aim to shed light on a mythical entity. Dragons? No... An effective and repeatable data-centric machine learning workflow, of course! It seems that many machine learning researchers and engineers these days are focused on developing the optimal model architecture for their tasks. In reality, the most surefire way to achieve a high-performing model is to meticulously understand, track, and improve your datasets and experimental results.\n", "\n", "In this notebook, we will walk through the process of developing a computer vision model and dataset in a repeatable and effective way utilizing [ClearML](https://clear.ml/) and [FiftyOne](https://fiftyone.ai). Specifically, we will be training the object detection model DETR on a dataset of dragon images, though the general workflow presented is extensible to nearly any computer vision and machine learning task.\n", "\n", "[FiftyOne](https://fiftyone.ai) is an open-source tool for building high-quality datasets and computer vision models with a [powerful API](https://voxel51.com/docs/fiftyone/user_guide/using_views.html) and [intuitive App](https://voxel51.com/docs/fiftyone/user_guide/app.html) letting you quickly understand the quality of your dataset, find your model's failure modes, and improve your datasets and models. On the other hand, [ClearML](https://clear.ml/) is an open-source platform that automates and simplifies developing and managing machine learning solutions through an end-to-end MLOps suite allowing you to focus on developing your ML code and automation, while ClearML ensures your work is reproducible and scalable.\n", "\n", "ClearML and FiftyOne go hand-in-hand with one another in your machine learning workflows. The combination of flexible, hands-on visualization and analysis of data and model results of FiftyOne combined with the experimental result tracking of ClearML produces a system that lets you quickly explore and improve your datasets while also persisting all of the changes and progress made to achieving a high-performing model." ] }, { "cell_type": "markdown", "id": "incoming-royal", "metadata": {}, "source": [ "## Setup\n", "\n", "To start, we will need to [install FiftyOne](https://voxel51.com/docs/fiftyone/getting_started/install.html) and [ClearML](https://clear.ml/):\n" ] }, { "cell_type": "code", "execution_count": null, "id": "sufficient-variance", "metadata": {}, "outputs": [], "source": [ "!pip install fiftyone" ] }, { "cell_type": "markdown", "id": "informative-japanese", "metadata": {}, "source": [ "In order to start tracking your experiments you'll need a free clearML account to send data to the community server or you can always host your own server too!" ] }, { "cell_type": "code", "execution_count": null, "id": "overall-encyclopedia", "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Preferably run this in a terminal if you can, but if in a (colab) notebook\n", "# the input is not recognised properly. Press enter once, to give clearml-init\n", "# an empty input and then fill in the fields one at a time.\n", "!pip install clearml\n", "!clearml-init" ] }, { "cell_type": "markdown", "id": "fixed-geometry", "metadata": {}, "source": [ "Download the DETR repository that has been updated with the clearML experiment tracking code." ] }, { "cell_type": "code", "execution_count": 31, "id": "small-bullet", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/content2\n" ] } ], "source": [ "%cd /content" ] }, { "cell_type": "code", "execution_count": null, "id": "elder-zimbabwe", "metadata": {}, "outputs": [], "source": [ "# This is for when running in colab\n", "!git clone https://github.com/thepycoder/detr.git" ] }, { "cell_type": "markdown", "id": "corrected-ticket", "metadata": {}, "source": [ "Also import torch and check if a GPU is available" ] }, { "cell_type": "code", "execution_count": 8, "id": "ranking-sauce", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.10.0 True\n" ] } ], "source": [ "import torch\n", "import fiftyone\n", "from datetime import datetime\n", "print(torch.__version__, torch.cuda.is_available())" ] }, { "cell_type": "markdown", "id": "hawaiian-brother", "metadata": {}, "source": [ "The rest of the clearml-specific code is added in the `main.py` file and will keep track of every time it is ran from here. Keeping track of all the variables, arguments, metrics, model files and so on." ] }, { "cell_type": "markdown", "id": "second-least", "metadata": {}, "source": [ "## [The Tale of the Data and the Model FAIR](https://awoiaf.westeros.org/index.php/The_Bear_and_the_Maiden_Fair)" ] }, { "cell_type": "markdown", "id": "biological-madness", "metadata": {}, "source": [ "To keep things interesting, we created a whole new dataset especially for the occasion: dragons! We gathered 115 images of dragons and annotated them. Interestingly they are both cartoon-style dragons and more 'realistic' dragons.\n", "\n", "To start things out, let's download the dataset. [This repository](https://github.com/thepycoder/dragon_data) will download the images for you. Later on we will use this dataset directly to train a model and visualize the results." ] }, { "cell_type": "code", "execution_count": 31, "id": "acknowledged-destination", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/content2\n" ] } ], "source": [ "%cd /content" ] }, { "cell_type": "code", "execution_count": null, "id": "prostate-throw", "metadata": {}, "outputs": [], "source": [ "!git clone https://github.com/thepycoder/dragon_data" ] }, { "cell_type": "markdown", "id": "fixed-baking", "metadata": {}, "source": [ "Let's download the data to our disk by using the `get_dataset.py` script from the repo." ] }, { "cell_type": "code", "execution_count": 7, "id": "diagnostic-international", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/content2/dragon_data\n", "100%|███████████████████████████████████████████| 98/98 [00:14<00:00, 6.75it/s]\n", "100%|███████████████████████████████████████████| 10/10 [00:01<00:00, 6.39it/s]\n" ] } ], "source": [ "%cd dragon_data\n", "!python get_dataset.py" ] }, { "cell_type": "markdown", "id": "noble-fields", "metadata": {}, "source": [ "In the next section, we look at [Meta (Facebook) research's DETR](https://github.com/facebookresearch/detr), an object detection network based on the popular transformers architecture that we used and updated with ClearML experiment tracking capabilities." ] }, { "cell_type": "markdown", "id": "tight-arrow", "metadata": {}, "source": [ "## Integrating ClearML Experiment Tracking into Pytorch DETR" ] }, { "cell_type": "markdown", "id": "vanilla-captain", "metadata": {}, "source": [ "The main entrypoint in the original DETR code is the `main.py` script, which contains the main training loop. To start tracking our training runs in clearML we simply have to add 2 lines of code this script and we're off to the races!\n", "\n", "You can check this change in `main.py` starting from line 19.\n", "```python\n", "# Imports ...\n", "\n", "# Initialise a clearML task and its corresponding logger\n", "from clearml import Task\n", "task = Task.init(project_name='dragon_detector', task_name=f'DETR')\n", "\n", "# Rest of code ...\n", "```\n", "\n", "These 2 lines will already log all hyperparameters used, console output, code changes and much more.\n", "\n", "![parameters](images/training_clearml_detector/parameters.png)\n", "\n", "![artifacts](images/training_clearml_detector/artifacts.png)\n", "\n", "![console](images/training_clearml_detector/console.png)" ] }, { "cell_type": "markdown", "id": "compatible-thing", "metadata": {}, "source": [ "### Manually adding scalars" ] }, { "cell_type": "markdown", "id": "sunrise-salon", "metadata": {}, "source": [ "When using popular frameworks like detectron2, tensorboard and others, scalars (e.g. loss, mAP etc.) will automatically be logged by clearML. But in case you have a model implementation where this does not happen automatically, it's still very easy to add parameters to log manually.\n", "\n", "First, we add a clearML logger. Ideally, we place it under the 2 magic lines of code we just put in.\n", "\n", "You can check this change in `main.py` starting from line 22.\n", "```python\n", "# Imports ...\n", "\n", "# Initialise a clearML task and its corresponding logger\n", "from clearml import Task\n", "task = Task.init(project_name='dragon_detector', task_name=f'DETR')\n", "logger = task.get_logger()\n", "\n", "# Rest of code ...\n", "```\n", "\n", "Next, we can use this logger to add anything we want to the clearML report. In this case, DETR already keeps track of many important variables such as epoch number, all different losses for that epoch, training and testing accuracy etc. It keeps track of these metrics in a dict, so all we have to do is add this dict to our logger and BOOM! We're tracking them!\n", "\n", "In this case we did some additional things: we only log these metrics every 10 epochs and filter out the `coco_eval_bbox` key from the dictionary as it is not a metric, but a bounding box which is difficult to plot...\n", "\n", "```python\n", "\n", "# Original DETR evaluation step\n", "test_stats, coco_evaluator = evaluate(\n", " model, criterion, postprocessors, data_loader_val, base_ds, device, args.output_dir\n", ")\n", "\n", "# Original DETR dict containing metrics\n", "log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},\n", " **{f'test_{k}': v for k, v in test_stats.items()},\n", " 'epoch': epoch,\n", " 'n_parameters': n_parameters}\n", "\n", "# Added ClearML tracking\n", "if epoch % 10 == 0:\n", " for key, value in log_stats.items():\n", " if 'coco_eval_bbox' in key:\n", " continue\n", " logger.report_scalar(title=key, series=key, value=value, iteration=epoch)\n", "\n", "```\n", "\n", "In the clearML dashboard, you'll find these metrics under Results -> Scalars and they'll be plotted for you.\n", "\n", "![clearml scalar view](images/training_clearml_detector/scalars.png)\n", "\n" ] }, { "cell_type": "markdown", "id": "prime-november", "metadata": {}, "source": [ "### Manually adding debug samples" ] }, { "cell_type": "markdown", "id": "polyphonic-monday", "metadata": {}, "source": [ "Finally, we would like to add Debug Samples. This is where you can log images and their detections straight to the clearML dashboard, so we can visually see that our training has worked!\n", "Again, if using something like tensorboard, debug images will be captured automatically but DETR did not evaluate any images in it's training loop, so we'll have to add a little more code now to get them.\n", "\n", "\n", "First, we're mainly interested in the detection quality at the end of training. So we add a custom function at the complete end of the training script, that will run evaluation with the currently trained model on all the validation images and log them to clearML.\n", "\n", "In `main.py` we add a function call to run evaluation on validation images: line 263 (last line)\n", "```python\n", "# Main entrypoint of training script\n", "if __name__ == '__main__':\n", " parser = argparse.ArgumentParser('DETR training and evaluation script', parents=[get_args_parser()])\n", " args = parser.parse_args()\n", " if args.output_dir:\n", " Path(args.output_dir).mkdir(parents=True, exist_ok=True)\n", " main(args)\n", " run_visual_validation(args, ['dragon'], logger)\n", "```\n", "\n", "The `run_visual_validation` function loads the model we just trained and sends a call to `run_visual_validation_workflow` for every validation image we have.\n", "```python\n", "def run_visual_validation(args, classes, logger):\n", " # Get the model ready\n", " model = torch.hub.load('facebookresearch/detr',\n", " 'detr_resnet50',\n", " pretrained=False,\n", " num_classes=args.num_classes)\n", " checkpoint = torch.load(Path(args.output_dir) / 'checkpoint.pth',\n", " map_location='cpu')\n", "\n", " model.load_state_dict(checkpoint['model'],\n", " strict=False)\n", " model.eval()\n", "\n", " # Iterate over the validation folder and run the model. For visual feedback.\n", " val_folder = Path(args.coco_path) / 'val'\n", " for img_name in os.listdir(val_folder):\n", " im = Image.open(Path(val_folder) / img_name)\n", " run_visual_validation_workflow(im, model, classes, logger, img_name)\n", "```\n", "\n", "The `run_visual_validation_workflow` on it's turn will take the validation image, normalize it, run it through the model, filter the predictions on a threshold and send the result out to be plotted.\n", "```python\n", "def run_visual_validation_workflow(my_image, my_model, classes, logger, img_name):\n", " # mean-std normalize the input image (batch-size: 1)\n", " img = transform(my_image).unsqueeze(0)\n", "\n", " # propagate through the model\n", " outputs = my_model(img)\n", "\n", " probas_to_keep, bboxes_scaled = filter_bboxes_from_outputs(outputs,\n", " img,\n", " threshold=0.35)\n", "\n", " plot_image_results(my_image,\n", " probas_to_keep,\n", " bboxes_scaled,\n", " classes,\n", " logger,\n", " img_name)\n", "```\n", "\n", "Finally, `plot_image_results` will make a matplotlib image from the validation image and the relevant predictions. Then with the single line `logger.report_matplotlib_figure` we send that matplotlib image to clearML. This is the only actual clearML line of code you need, the rest is needed to create the images.\n", "```python\n", "def plot_image_results(pil_img, prob, boxes, classes, logger, img_name):\n", " # colors for visualization\n", " colors = [[0.000, 0.447, 0.741], [0.850, 0.325, 0.098], [0.929, 0.694, 0.125],\n", " [0.494, 0.184, 0.556], [0.466, 0.674, 0.188], [0.301, 0.745, 0.933]]\n", " colors = colors * 100\n", " figure = plt.figure(figsize=(16,10))\n", " plt.imshow(pil_img)\n", " ax = plt.gca()\n", " for p, (xmin, ymin, xmax, ymax), c in zip(prob, boxes.tolist(), colors):\n", " ax.add_patch(plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin,\n", " fill=False, color=c, linewidth=3))\n", " cl = p.argmax()\n", " text = f'{classes[cl]}: {p[cl]:0.2f}'\n", " ax.text(xmin, ymin, text, fontsize=15,\n", " bbox=dict(facecolor='yellow', alpha=0.5))\n", " plt.axis('off')\n", " plt.savefig(img_name)\n", " logger.report_matplotlib_figure('Evaluation Results', img_name, figure,\n", " iteration=None, report_image=True,\n", " report_interactive=False)\n", "```\n", "\n", "This all leads to a very handy overview of the model performance in the clearML dashboard as can be seen below\n", "\n", "![debug samples](images/training_clearml_detector/debug_samples.png)\n" ] }, { "cell_type": "markdown", "id": "graphic-crystal", "metadata": {}, "source": [ "## Train DETR\n", "\n", "Since the data in our dragon dataset is limited, our model should be pretrained. \n", "\n", "This means getting a pretrained model and chopping off the class head, so we can retrain that part only." ] }, { "cell_type": "code", "execution_count": 32, "id": "super-level", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/content2/detr\n" ] } ], "source": [ "%cd /content/detr" ] }, { "cell_type": "code", "execution_count": null, "id": "special-gamma", "metadata": {}, "outputs": [], "source": [ "!pip install -r requirements.txt\n", "!pip install pandas seaborn" ] }, { "cell_type": "code", "execution_count": 33, "id": "stretch-track", "metadata": {}, "outputs": [], "source": [ "# Get pretrained weights\n", "checkpoint = torch.hub.load_state_dict_from_url(\n", " url='https://dl.fbaipublicfiles.com/detr/detr-r50-e632da11.pth',\n", " map_location='cpu',\n", " check_hash=True)\n", "\n", "# Remove class weights\n", "del checkpoint[\"model\"][\"class_embed.weight\"]\n", "del checkpoint[\"model\"][\"class_embed.bias\"]\n", "\n", "# SaveOGH\n", "torch.save(checkpoint, 'detr-r50_no-class-head.pth')" ] }, { "cell_type": "markdown", "id": "brief-stick", "metadata": {}, "source": [ "Our dataset is loadable in a COCO format which is expected by the main python script of DETR." ] }, { "cell_type": "code", "execution_count": 36, "id": "swiss-bronze", "metadata": {}, "outputs": [], "source": [ "dataset_file = \"dragons\" # alternatively, implement your own coco-type dataset loader in datasets and add this \"key\" to datasets/__init__.py\n", "\n", "dataDir = '/content/dragon_data/data' # should lead to a directory with a train and val folder as well as an annotations folder\n", "num_classes = 2 # this int should be the amount of classes + 1\n", "\n", "outDir = f'outputs_{datetime.now().strftime(\"%m:%d:%Y_%H:%M:%S\")}'\n", "resume = \"detr-r50_no-class-head.pth\"" ] }, { "cell_type": "markdown", "id": "ethical-knitting", "metadata": {}, "source": [ "Start training!" ] }, { "cell_type": "code", "execution_count": 47, "id": "equipped-frequency", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ClearML Task: created new task id=e551155d03d0424dafcfa14547b9585c\n", "ClearML results page: https://app.community.clear.ml/projects/8131d2f23983461f8354156be95bc4f1/experiments/e551155d03d0424dafcfa14547b9585c/output/log\n", "Using cache found in /root/.cache/torch/hub/facebookresearch_detr_main\n", "2021-12-16 11:04:49,754 - clearml.model - INFO - Selected model id: 3ce34161504342838a56bf457a7ec2e7\n", "Running visual validation on outputs_12:16:2021_09:40:47\n", "2021-12-16 11:04:53,419 - clearml.model - INFO - Selected model id: 127e4ace5efe45e598f26f86ffb636e5\n", "/content2/detr/models/position_encoding.py:41: UserWarning:\n", "\n", "__floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n", "\n", "2021-12-16 11:05:30,662 - clearml.Task - INFO - Waiting to finish uploads\n", "2021-12-16 11:05:33,253 - clearml.Task - INFO - Finished uploading\n" ] } ], "source": [ "# We need at least 100 epochs for the dragons to be detected somewhat decently. It seems to be a difficult class.\n", "!python main.py \\\n", " --dataset_file $dataset_file \\\n", " --coco_path $dataDir \\\n", " --output_dir $outDir \\\n", " --resume $resume \\\n", " --num_classes $num_classes \\\n", " --lr 1e-5 \\\n", " --lr_backbone 1e-6 \\\n", " --epochs 50" ] }, { "cell_type": "markdown", "id": "changing-accordance", "metadata": {}, "source": [ "## ClearML Experiment Results\n", "\n", "Quick and easy overview of the tracked training results, an interactive version of these graphs should be visible on your clearML dashboard!" ] }, { "cell_type": "code", "execution_count": 20, "id": "official-forum", "metadata": {}, "outputs": [], "source": [ "from util.plot_utils import plot_logs\n", "from pathlib import Path\n", "\n", "log_directory = [Path(outDir)]" ] }, { "cell_type": "code", "execution_count": 21, "id": "ongoing-senegal", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fields_of_interest = (\n", " 'loss',\n", " 'mAP',\n", " )\n", "\n", "plot_logs(log_directory,\n", " fields_of_interest)" ] }, { "cell_type": "code", "execution_count": 22, "id": "sought-bread", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fields_of_interest = (\n", " 'loss_ce',\n", " 'loss_bbox',\n", " 'loss_giou',\n", " )\n", "\n", "plot_logs(log_directory,\n", " fields_of_interest)" ] }, { "cell_type": "code", "execution_count": 23, "id": "stainless-league", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fields_of_interest = (\n", " 'class_error',\n", " 'cardinality_error_unscaled',\n", " )\n", "\n", "plot_logs(log_directory,\n", " fields_of_interest) " ] }, { "cell_type": "markdown", "id": "activated-florida", "metadata": {}, "source": [ "If we want to dig deeper and debug our model's performance meticulously, we can analyze it using FiftyOne!" ] }, { "cell_type": "markdown", "id": "demonstrated-romania", "metadata": {}, "source": [ "## Digging in with FiftyOne" ] }, { "cell_type": "markdown", "id": "paperback-prefix", "metadata": {}, "source": [ "To start, let's [load the dataset into FiftyOne](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/index.html) so we can take a look at it in the [FiftyOne App](https://voxel51.com/docs/fiftyone/user_guide/app.html). Loading any custom dataset into FiftyOne is as simple as writing a Python loop. However, since this dataset is already in COCO format, we can load it with just one line of code. " ] }, { "cell_type": "code", "execution_count": 4, "id": "absolute-horse", "metadata": {}, "outputs": [], "source": [ "import fiftyone as fo\n", "import os" ] }, { "cell_type": "code", "execution_count": 12, "id": "asian-helena", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/content2\n" ] } ], "source": [ "%cd /content\n", "# Should lead to a directory with a train and val folder as well as an annotations folder\n", "dataset_dir = \"dragon_data/data\"\n", "dataset_name = \"dragons\"\n", "\n", "# Reload the dataset if it was persistent\n", "if dataset_name in fo.list_datasets():\n", " fo.delete_dataset(dataset_name)" ] }, { "cell_type": "code", "execution_count": 13, "id": "introductory-drilling", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 100% |███████████████████| 98/98 [198.9ms elapsed, 0s remaining, 492.7 samples/s] \n", " 100% |███████████████████| 10/10 [15.1ms elapsed, 0s remaining, 662.2 samples/s] \n" ] }, { "data": { "text/plain": [ "['61bb163f336bdf908449101a',\n", " '61bb163f336bdf908449101e',\n", " '61bb163f336bdf908449101f',\n", " '61bb163f336bdf9084491026',\n", " '61bb163f336bdf9084491027',\n", " '61bb163f336bdf9084491028',\n", " '61bb163f336bdf9084491029',\n", " '61bb163f336bdf9084491031',\n", " '61bb163f336bdf9084491032',\n", " '61bb163f336bdf9084491033']" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Load the training dataset into FiftyOne and tag all samples with \"train\"\n", "dataset = fo.Dataset.from_dir(\n", " dataset_type=fo.types.COCODetectionDataset,\n", " data_path= os.path.join(dataset_dir, \"train\"),\n", " labels_path= os.path.join(dataset_dir, \"annotations/train.json\"),\n", " name=dataset_name,\n", " tags=\"train\",\n", ")\n", "\n", "# Add the validation data and tag the samples with \"val\"\n", "dataset.add_dir(\n", " dataset_type=fo.types.COCODetectionDataset,\n", " data_path= os.path.join(dataset_dir, \"val\"),\n", " labels_path= os.path.join(dataset_dir, \"annotations/val.json\"),\n", " tags=\"val\",\n", ")" ] }, { "cell_type": "markdown", "id": "vocational-colon", "metadata": {}, "source": [ "The `launch_app()` method launches the App directly in the output of this cell and also returns a Session instance, which you can subsequently use to interact programmatically with the App." ] }, { "cell_type": "code", "execution_count": 22, "id": "other-italic", "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(dataset)" ] }, { "cell_type": "code", "execution_count": null, "id": "loaded-luxembourg", "metadata": {}, "outputs": [], "source": [ "session.freeze() # Screenshot the App for this example" ] }, { "cell_type": "markdown", "id": "ideal-relief", "metadata": {}, "source": [ "### Loading predictions into FiftyOne\n", "\n", "Similar to how you load ground truth labels into a FiftyOne Dataset, [loading model predictions](https://voxel51.com/docs/fiftyone/user_guide/dataset_creation/index.html#model-predictions) is as easy as writing a Python loop. In general, loading predictions follows this pseudocode:\n", "\n", "```python\n", "import fiftyone as fo\n", "\n", "dataset = fo.load_dataset(\"dragons\")\n", "img_paths = [\"/path/to/img1.png\", ...]\n", "\n", "# Ex. custom prediction format: [bbox, label, confidence]\n", "predictions = [[[0.1,0.2,0.3,0.5], \"car\", 0.921], ...]\n", "\n", "for img_path, img_preds in zip(img_paths, predictions):\n", " sample = dataset[img_path]\n", " dets = []\n", " for bbox, label, conf in img_preds:\n", " dets.append(\n", " fo.Detection(\n", " bounding_box=bbox,\n", " label=label,\n", " confidence=confidence,\n", " )\n", " )\n", " sample[\"predictions\"] = fo.Detections(detections=dets)\n", " sample.save()\n", "\n", "# View predictions in the App\n", "session = fo.launch_app(dataset)\n", "```\n", "\n", "Specifically, the following function iterates through a FiftyOne dataset, loads the image data, generates predictions, and stores those predictions on the dataset in FiftyOne format." ] }, { "cell_type": "code", "execution_count": null, "id": "opposite-sacramento", "metadata": {}, "outputs": [], "source": [ "from PIL import Image\n", "import torchvision.transforms as T\n", "\n", "def run_inference(samples, model, classes=[\"background\", \"dragon\"]):\n", " # standard PyTorch mean-std input image normalization\n", " transform = T.Compose([\n", " T.Resize(800),\n", " T.ToTensor(),\n", " T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", " ])\n", "\n", " # Iterate over `samples`, a FiftyOne dataset or view\n", " for sample in samples.iter_samples(progress=True):\n", " image = Image.open(sample.filepath)\n", " if image.mode != \"RGB\":\n", " image = image.convert(\"RGB\")\n", "\n", " # Mean-std normalize the input image (batch-size: 1)\n", " image = transform(image).unsqueeze(0)\n", "\n", " # Perform inference\n", " preds = model(image)\n", "\n", " scores = preds[\"pred_logits\"].softmax(-1)[0, :, :-1]\n", "\n", " keep_thresh = 0.2\n", " keep = scores.max(-1).values > keep_thresh\n", "\n", " scores = scores[keep].cpu().detach().numpy()\n", " boxes = preds[\"pred_boxes\"][0, keep].cpu().detach().numpy()\n", "\n", " # Convert detections to FiftyOne format\n", " detections = [] \n", " for score, box in zip(scores, boxes):\n", " # Output boxes in [center-x, center-y, width, height]\n", " # Convert to [top-left-x, top-left-y, width, height]\n", " cx, cy, w, h = box\n", " formatted_box = [cx - 0.5 * w, cy - 0.5 * h, w, h]\n", "\n", " label_ind = score.argmax()\n", " label = classes[label_ind]\n", " confidence = score[label_ind]\n", "\n", " detections.append(\n", " fo.Detection(\n", " label=label,\n", " bounding_box=formatted_box,\n", " confidence=confidence,\n", " )\n", " )\n", "\n", " # Save predictions to dataset\n", " sample[\"predictions\"] = fo.Detections(detections=detections)\n", " sample.save()" ] }, { "cell_type": "markdown", "id": "serial-electric", "metadata": {}, "source": [ "Now let's load the model we just trained and add its predictions to our FiftyOne dataset." ] }, { "cell_type": "code", "execution_count": null, "id": "rational-source", "metadata": {}, "outputs": [], "source": [ "detr_path = \"detr\"\n", "num_classes = 2\n", "\n", "model = torch.hub.load('facebookresearch/detr',\n", " 'detr_resnet50',\n", " pretrained=False,\n", " num_classes=num_classes)\n", "\n", "checkpoint = torch.load(f'{outDir}/checkpoint.pth', map_location='cpu')\n", "\n", "model.load_state_dict(checkpoint['model'],\n", " strict=False)\n", "\n", "model.eval()" ] }, { "cell_type": "code", "execution_count": 16, "id": "interracial-chicago", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1% |/----------------| 1/108 [942.4ms elapsed, 1.7m remaining, 1.1 samples/s] " ] }, { "name": "stderr", "output_type": "stream", "text": [ "/root/.cache/torch/hub/facebookresearch_detr_main/models/position_encoding.py:41: UserWarning: __floordiv__ is deprecated, and its behavior will change in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values. To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor').\n", " dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 100% |█████████████████| 108/108 [1.8m elapsed, 0s remaining, 1.3 samples/s] \n" ] } ], "source": [ "run_inference(dataset, model)" ] }, { "cell_type": "markdown", "id": "vocational-belarus", "metadata": {}, "source": [ "We can easily visualize the predictions in the FiftyOne App." ] }, { "cell_type": "code", "execution_count": 7, "id": "treated-guinea", "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(dataset)" ] }, { "cell_type": "code", "execution_count": 9, "id": "found-observer", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "simple-hypothesis", "metadata": {}, "source": [ "Once the predictions are in FiftyOne, we can easily export them in COCO format into a JSON file on disk." ] }, { "cell_type": "code", "execution_count": null, "id": "bulgarian-speaking", "metadata": {}, "outputs": [], "source": [ "# Export predictions from FiftyOne dataset to disk in COCO-formatted JSON\n", "dataset.export(\n", " label_field=\"predictions\",\n", " label_path=\"/path/to/coco_predictions.json\",\n", " dataset_type=fo.types.COCODetectionDataset,\n", ")" ] }, { "cell_type": "markdown", "id": "increased-employment", "metadata": {}, "source": [ " We can then upload this JSON file to our ClearML dataset to keep track of the model predictions for this iteration of the data." ] }, { "cell_type": "markdown", "id": "happy-spouse", "metadata": {}, "source": [ "### Evaluating and Filtering Results\n", "\n", "Now that the model predictions are loaded, we can dig in and analyze the results. FiftyOne provides [methods for evaluating classification, detection, and segmentation](https://voxel51.com/docs/fiftyone/user_guide/evaluation.html) models. While these methods can be used to compute dataset-wide metrics like so many other tools, the primary benefit is that this evaluation also populates instance-level results on the dataset like tagging individual true or false positive predictions. This allows you to not only understand how the model performs on the dataset as a whole but also specific instances in which the model performs well or poorly which is the best way to build intuition about the type of data you should use to retrain the model." ] }, { "cell_type": "code", "execution_count": 4, "id": "motivated-development", "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": null, "id": "sound-bulgarian", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "aging-yeast", "metadata": {}, "source": [ "Visualizing predictions in FiftyOne shows many low confidence incorrect predictions. This indicates that we should find an appropriate confidence threshold to limit the predictions in the dataset. " ] }, { "cell_type": "markdown", "id": "formal-ecuador", "metadata": {}, "source": [ "One way to find a threshold value for detection confidence is to calculate the number of true and false positives that exist currently and find the point at which there are an equal number of both." ] }, { "cell_type": "markdown", "id": "finnish-suspension", "metadata": {}, "source": [ "Let's call the [`evalute_detections()`](https://voxel51.com/docs/fiftyone/user_guide/evaluation.html#detections) method to use COCO-style object detection evaluation to compute if each ground truth and prediction is either a true positive, false positive, or false negative." ] }, { "cell_type": "code", "execution_count": 30, "id": "hawaiian-penguin", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating detections...\n", " 100% |█████████████████| 108/108 [532.6ms elapsed, 0s remaining, 202.8 samples/s] \n", "Performing IoU sweep...\n", " 100% |█████████████████| 108/108 [898.6ms elapsed, 0s remaining, 120.2 samples/s] \n" ] } ], "source": [ "eval_key = \"full_dataset_eval\"\n", "results = dataset.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " eval_key=eval_key, \n", ")" ] }, { "cell_type": "markdown", "id": "historic-trance", "metadata": {}, "source": [ "The FiftyOne API provides a [powerful query language](https://voxel51.com/docs/fiftyone/user_guide/using_views.html#) that can be used to [filter and slice datasets](https://voxel51.com/docs/fiftyone/user_guide/using_views.html#filtering) letting you look at the specific view in which you are interested. It also provides [dataset-wide aggregation functions](https://voxel51.com/docs/fiftyone/user_guide/using_aggregations.html) that let you easily access content from your datasets such as label values, counts, distributions, and ranges. One of these aggregations is the [`histogram_values()`](https://voxel51.com/docs/fiftyone/user_guide/using_aggregations.html#histogram-values) function that is perfect for our use case of computing the number of true and false positives for each confidence bin." ] }, { "cell_type": "code", "execution_count": null, "id": "aboriginal-perspective", "metadata": {}, "outputs": [], "source": [ "from fiftyone import ViewField as F" ] }, { "cell_type": "code", "execution_count": null, "id": "assigned-forum", "metadata": {}, "outputs": [], "source": [ "tp_view = dataset.filter_labels(\"predictions\", F(eval_key) == \"tp\")\n", "fp_view = dataset.filter_labels(\"predictions\", F(eval_key) == \"fp\")" ] }, { "cell_type": "code", "execution_count": null, "id": "authentic-relevance", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": null, "id": "brown-necessity", "metadata": {}, "outputs": [], "source": [ "def plot_hist(counts, edges):\n", " counts = np.asarray(counts)\n", " edges = np.asarray(edges)\n", " left_edges = edges[:-1]\n", " widths = edges[1:] - edges[:-1]\n", " plt.bar(left_edges, counts, width=widths, align=\"edge\")" ] }, { "cell_type": "code", "execution_count": 71, "id": "sensitive-funds", "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "tp_counts, tp_edges, other = tp_view.histogram_values(\"predictions.detections.confidence\", bins=50)\n", "plot_hist(tp_counts, tp_edges)" ] }, { "cell_type": "code", "execution_count": 73, "id": "acoustic-shopper", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fp_counts, fp_edges, other = fp_view.histogram_values(\"predictions.detections.confidence\", bins=50)\n", "plot_hist(fp_counts, fp_edges)" ] }, { "cell_type": "markdown", "id": "plain-sapphire", "metadata": {}, "source": [ "Let's integrate over this histogram starting at the highest confidence to find the confidence at which the number of true positives equals the number of false positives." ] }, { "cell_type": "code", "execution_count": 74, "id": "accessory-weight", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(tp_edges[:-1][::-1], np.cumsum(tp_counts[::-1]))\n", "plt.plot(fp_edges[:-1][::-1], np.cumsum(fp_counts[::-1]))\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "nearby-print", "metadata": {}, "source": [ "Based on this graph, we should set our confidence threshold to around 0.5. Let's visualize the dataset in the FiftyOne App to visually check how well this confidence threshold works for this problem." ] }, { "cell_type": "code", "execution_count": 41, "id": "sustained-bristol", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", " \n", "
\n", " \n", "
\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "session.dataset = dataset" ] }, { "cell_type": "code", "execution_count": 5, "id": "continued-logan", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "sapphire-convertible", "metadata": {}, "source": [ "After browsing through the samples in the dataset, a threshold of 0.5 provides enough flexibility to detect many of the dragons in the dataset without too many false positives.\n", "\n", "Now, let's create a view programmatically using this confidence threshold and reevaluate the model predictions, computing COCO-style mAP as well this time." ] }, { "cell_type": "code", "execution_count": null, "id": "conceptual-salvation", "metadata": {}, "outputs": [], "source": [ "conf_thresh = 0.5\n", "high_conf_view = dataset.filter_labels(\"predictions\", F(\"confidence\") > conf_thresh)" ] }, { "cell_type": "code", "execution_count": 44, "id": "polar-pierce", "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.view = high_conf_view" ] }, { "cell_type": "code", "execution_count": null, "id": "detected-hospital", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "code", "execution_count": null, "id": "structured-guard", "metadata": {}, "outputs": [], "source": [ "eval_key = \"eval\"" ] }, { "cell_type": "code", "execution_count": 76, "id": "detected-baptist", "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating detections...\n", " 100% |█████████████████| 101/101 [1.1s elapsed, 0s remaining, 94.7 samples/s] \n", "Performing IoU sweep...\n", " 100% |█████████████████| 101/101 [660.0ms elapsed, 0s remaining, 153.0 samples/s] \n" ] } ], "source": [ "results = high_conf_view.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " eval_key=eval_key, \n", " compute_mAP=True,\n", ")" ] }, { "cell_type": "code", "execution_count": 78, "id": "purple-raleigh", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.3416714132507098\n" ] } ], "source": [ "print(results.mAP())" ] }, { "cell_type": "markdown", "id": "suspended-professional", "metadata": {}, "source": [ "### What can our failures teach us?\n", "\n", "One of the primary uses of FiftyOne is the ability to easily query and explore your dataset and model predictions for any question that comes to mind. An especially useful workflow is to explore the failure modes of your model to get a sense of how to best improve it going forward.\n", "\n", "For example, let's take a look at all of the predictions that were false positives but with high confidence, indicating that the model was fairly certain about its detection but was incorrect. These types of examples usually indicate either an ingrained issue with the model or an error in the ground truth annotations. Either need to be addressed promptly." ] }, { "cell_type": "code", "execution_count": null, "id": "dirty-quest", "metadata": {}, "outputs": [], "source": [ "high_conf_fp = high_conf_view.filter_labels(\n", " \"predictions\",\n", " (F(eval_key) == \"fp\") & (F(\"confidence\") > 0.9),\n", ")" ] }, { "cell_type": "code", "execution_count": 80, "id": "forward-reason", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", " \n", "
\n", " \n", "
\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "session.view = high_conf_fp" ] }, { "cell_type": "code", "execution_count": null, "id": "tamil-strike", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "initial-sellers", "metadata": {}, "source": [ "From the example above, it seems that one issue with our dataset is that we did not consistently annotate the wings of dragons. The model relatively accurately detected the dragon, but also included the wing which resulted in an IoU below the threshold used for evaluation (IoU=0.5). This detection would not necessarily be incorrect, though, so we may want to take a pass over the dataset to ensure dragon wings are consistently annotated.\n", "\n", "An easy way to reannotate this dataset is to use the integrations between FiftyOne and annotation tools like [CVAT](https://voxel51.com/docs/fiftyone/integrations/cvat.html) or [Labelbox](https://voxel51.com/docs/fiftyone/integrations/labelbox.html).\n", "\n", "Now, let's take a look at the false negatives in the dataset, where the model did not detect a ground truth object." ] }, { "cell_type": "code", "execution_count": null, "id": "binary-working", "metadata": {}, "outputs": [], "source": [ "fn_view = high_conf_view.filter_labels(\n", " \"ground_truth\",\n", " F(eval_key) == \"fn\",\n", ")" ] }, { "cell_type": "code", "execution_count": 83, "id": "confirmed-duplicate", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", " \n", "
\n", " \n", "
\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "session.view = fn_view" ] }, { "cell_type": "code", "execution_count": null, "id": "underlying-waste", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "prescription-ambassador", "metadata": {}, "source": [ "From the example above, we see another issue of the model incorrectly localizing the bounding box, even though it did detect the presence of a dragon. The comment about reannotating the dataset to include dragon wings still holds, however, it would also be useful to add additional training data to allow the model to learn to more accurately localize the boxes." ] }, { "cell_type": "code", "execution_count": 53, "id": "satellite-drive", "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.dataset = dataset" ] }, { "cell_type": "code", "execution_count": null, "id": "hearing-collaboration", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "decent-assumption", "metadata": {}, "source": [ "In the example above, we see that the model is frequently detection non-dragon objects as dragons. The majority of the samples in this dataset contain only one or a few dragons isolated from other objects. Thus, the model seems to be learning to just detect all of the focal objects in the scene.\n", "\n", "The best way to resolve this would be to add more scenes with multiple types of objects to the dataset as well as expand the classes to other object types so that the model is able to learn to better differentiate between dragons and other objects." ] }, { "cell_type": "markdown", "id": "color-scott", "metadata": {}, "source": [ "### Train vs Validation split\n", "\n", "You may have noticed that all of the examples above have included samples from both the training and validation splits. We can also create views to evaluate the training and validation samples separately." ] }, { "cell_type": "code", "execution_count": null, "id": "aggregate-forum", "metadata": {}, "outputs": [], "source": [ "train_view = high_conf_view.match_tags(\"train\")\n", "val_view = high_conf_view.match_tags(\"val\")" ] }, { "cell_type": "code", "execution_count": 86, "id": "prescribed-control", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating detections...\n", " 100% |███████████████████| 93/93 [615.8ms elapsed, 0s remaining, 151.0 samples/s] \n", "Performing IoU sweep...\n", " 100% |███████████████████| 93/93 [672.7ms elapsed, 0s remaining, 138.3 samples/s] \n", "Evaluating detections...\n", " 100% |█████████████████████| 8/8 [18.8ms elapsed, 0s remaining, 425.0 samples/s] \n", "Performing IoU sweep...\n", " 100% |█████████████████████| 8/8 [23.1ms elapsed, 0s remaining, 346.2 samples/s] \n" ] } ], "source": [ "train_results = train_view.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " compute_mAP=True,\n", ")\n", "val_results = val_view.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " compute_mAP=True,\n", ")" ] }, { "cell_type": "code", "execution_count": 87, "id": "political-distributor", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train mAP: 0.34209299981356495\n", "Val mAP: 0.43994970925664\n" ] } ], "source": [ "print(\"Train mAP: \", train_results.mAP())\n", "print(\"Val mAP: \", val_results.mAP())" ] }, { "cell_type": "markdown", "id": "searching-shipping", "metadata": {}, "source": [ "Given the similarity in performance between the train and validation splits, it appears there may be room for further improvement in model performance by continuing to train the model for a few more epochs.\n", "\n", "This also indicates that the analysis that we have performed on the combined train and validation splits seems to hold for unseen data." ] }, { "cell_type": "code", "execution_count": 19, "id": "charitable-partner", "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=val_view)" ] }, { "cell_type": "code", "execution_count": null, "id": "prerequisite-portrait", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "abroad-islam", "metadata": {}, "source": [ "### Visualizing Image Augmentation with FiftyOne\n", "\n", "Building a robust model for your task is the ultimate goal of most machine learning projects. However, creating a dataset that captures all scenarios to properly train and evaluate your model is impossible. To that end, augmenting existing data to increase the number of samples in your dataset can be a cheap and effective way to train more robust models and find evaluation cases in which your model is underperforming. \n", "\n", "In this section, we evaluate the model we trained previously on augmented images of dragons and compare the performance to the unaugmented data. The augmentations are performed with the [Python library imgaug](https://github.com/aleju/imgaug). See the attached Colab notebook for code details. In summary, we regenerate all of the samples in the FiftyOne dataset using imgaug augmentations." ] }, { "cell_type": "code", "execution_count": null, "id": "bronze-young", "metadata": {}, "outputs": [], "source": [ "!pip install imgaug" ] }, { "cell_type": "code", "execution_count": 8, "id": "headed-marble", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset.first().metadata" ] }, { "cell_type": "code", "execution_count": null, "id": "valued-divorce", "metadata": {}, "outputs": [], "source": [ "import os\n", "import numpy as np\n", "from PIL import Image\n", "\n", "import imgaug as ia\n", "import imgaug.augmenters as iaa\n", "\n", "def augment_sample(sample, label_field, augmentations, output_dir, tags=None):\n", " # Load an existing sample,\n", " # apply given augmentations to the image and bounding boxes,\n", " # and return the augmented Sample\n", " \n", " os.makedirs(output_dir, exist_ok=True)\n", " image = Image.open(sample.filepath)\n", " if image.mode != \"RGB\":\n", " image = image.convert(\"RGB\")\n", " image = np.array(image)\n", " \n", " img_w = sample.metadata[\"width\"]\n", " img_h = sample.metadata[\"height\"]\n", " bbs = []\n", " labels = []\n", " for det in sample[label_field].detections:\n", " labels.append(det.label)\n", " tlx, tly, w, h = det.bounding_box\n", " \n", " # Convert from relative [tlx,tly,w,h] to absolute [x1,y1,x2,y2]\n", " ia_bbox = ia.BoundingBox(\n", " x1 = tlx * img_w,\n", " y1 = tly * img_h,\n", " x2 = (tlx + w) * img_w, \n", " y2 = (tly + h) * img_h,\n", " )\n", " bbs.append(ia_bbox)\n", " \n", " img_aug, bbs_aug = augmentations(images=[image], bounding_boxes=[bbs])\n", " img_aug, bbs_aug = img_aug[0], bbs_aug[0]\n", " aug_filepath = os.path.join(output_dir, sample.filename)\n", " output_img = Image.fromarray(img_aug)\n", " output_img.save(aug_filepath)\n", " aug_sample = fo.Sample(filepath=aug_filepath, tags=tags)\n", " \n", " img_h, img_w, _ = img_aug.shape\n", " dets = []\n", " for bb, label in zip(bbs_aug, labels):\n", " # Convert from absolute [x1,y1,x2,y2] to relative [tlx,tly,w,h]\n", " bbox = [\n", " bb.x1 / img_w,\n", " bb.y1 / img_h,\n", " (bb.x2 - bb.x1) / img_w,\n", " (bb.y2 - bb.y1) / img_h,\n", " ]\n", " det = fo.Detection(label=label, bounding_box=bbox)\n", " dets.append(det)\n", " \n", " aug_sample[label_field] = fo.Detections(detections=dets)\n", " \n", " return aug_sample" ] }, { "cell_type": "code", "execution_count": null, "id": "circular-language", "metadata": {}, "outputs": [], "source": [ "# Tag all existing samples to easily filter out augmentations in the future\n", "dataset.tag_samples(\"original\")" ] }, { "cell_type": "code", "execution_count": 42, "id": "oriented-partnership", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 100% |█████████████████| 108/108 [143.0ms elapsed, 0s remaining, 768.6 samples/s] \n" ] } ], "source": [ "tags = [\"augmented1\"]\n", "label_field = \"ground_truth\"\n", "output_dir = os.path.join(dataset_dir, \"augmented1\")\n", "augmentations = iaa.Sequential([\n", " iaa.AdditiveGaussianNoise(scale=0.05*255),\n", " iaa.Affine(translate_px={\"x\": (1, 5)})\n", "])\n", "\n", "aug_samples = []\n", "for sample in dataset.match_tags(\"original\"):\n", " aug_sample = augment_sample(\n", " sample,\n", " label_field,\n", " augmentations,\n", " output_dir,\n", " tags=tags,\n", " )\n", " aug_samples.append(aug_sample)\n", " \n", "_ = dataset.add_samples(aug_samples)" ] }, { "cell_type": "code", "execution_count": 43, "id": "dietary-butterfly", "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=dataset.match_tags(\"augmented1\"))" ] }, { "cell_type": "code", "execution_count": null, "id": "bridal-inflation", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "ecological-browser", "metadata": {}, "source": [ "Let's also add some much more difficult augmentations (these are directly from an Imgaug example).\n" ] }, { "cell_type": "code", "execution_count": null, "id": "logical-advertiser", "metadata": {}, "outputs": [], "source": [ "sometimes = lambda aug: iaa.Sometimes(0.5, aug)\n", "\n", "augmentations2 = iaa.Sequential(\n", " [\n", " # apply the following augmenters to most images\n", " iaa.Fliplr(0.5), # horizontally flip 50% of all images\n", " iaa.Flipud(0.2), # vertically flip 20% of all images\n", " # crop images by -5% to 10% of their height/width\n", " sometimes(iaa.CropAndPad(\n", " percent=(-0.05, 0.1),\n", " pad_mode=ia.ALL,\n", " pad_cval=(0, 255)\n", " )),\n", " sometimes(iaa.Affine(\n", " scale={\"x\": (0.8, 1.2), \"y\": (0.8, 1.2)}, # scale images to 80-120% of their size, individually per axis\n", " translate_percent={\"x\": (-0.2, 0.2), \"y\": (-0.2, 0.2)}, # translate by -20 to +20 percent (per axis)\n", " rotate=(-45, 45), # rotate by -45 to +45 degrees\n", " shear=(-16, 16), # shear by -16 to +16 degrees\n", " order=[0, 1], # use nearest neighbour or bilinear interpolation (fast)\n", " cval=(0, 255), # if mode is constant, use a cval between 0 and 255\n", " mode=ia.ALL # use any of scikit-image's warping modes (see 2nd image from the top for examples)\n", " )),\n", " # execute 0 to 5 of the following (less important) augmenters per image\n", " # don't execute all of them, as that would often be way too strong\n", " iaa.SomeOf((0, 5),\n", " [\n", " sometimes(iaa.Superpixels(p_replace=(0, 1.0), n_segments=(20, 200))), # convert images into their superpixel representation\n", " iaa.OneOf([\n", " iaa.GaussianBlur((0, 3.0)), # blur images with a sigma between 0 and 3.0\n", " iaa.AverageBlur(k=(2, 7)), # blur image using local means with kernel sizes between 2 and 7\n", " iaa.MedianBlur(k=(3, 11)), # blur image using local medians with kernel sizes between 2 and 7\n", " ]),\n", " iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)), # sharpen images\n", " iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)), # emboss images\n", " # search either for all edges or for directed edges,\n", " # blend the result with the original image using a blobby mask\n", " iaa.SimplexNoiseAlpha(iaa.OneOf([\n", " iaa.EdgeDetect(alpha=(0.5, 1.0)),\n", " iaa.DirectedEdgeDetect(alpha=(0.5, 1.0), direction=(0.0, 1.0)),\n", " ])),\n", " iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5), # add gaussian noise to images\n", " iaa.OneOf([\n", " iaa.Dropout((0.01, 0.1), per_channel=0.5), # randomly remove up to 10% of the pixels\n", " iaa.CoarseDropout((0.03, 0.15), size_percent=(0.02, 0.05), per_channel=0.2),\n", " ]),\n", " iaa.Invert(0.05, per_channel=True), # invert color channels\n", " iaa.Add((-10, 10), per_channel=0.5), # change brightness of images (by -10 to 10 of original value)\n", " iaa.AddToHueAndSaturation((-20, 20)), # change hue and saturation\n", " # either change the brightness of the whole image (sometimes\n", " # per channel) or change the brightness of subareas\n", " iaa.OneOf([\n", " iaa.Multiply((0.5, 1.5), per_channel=0.5),\n", " iaa.FrequencyNoiseAlpha(\n", " exponent=(-4, 0),\n", " first=iaa.Multiply((0.5, 1.5), per_channel=True),\n", " second=iaa.LinearContrast((0.5, 2.0))\n", " )\n", " ]),\n", " iaa.LinearContrast((0.5, 2.0), per_channel=0.5), # improve or worsen the contrast\n", " iaa.Grayscale(alpha=(0.0, 1.0)),\n", " sometimes(iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)), # move pixels locally around (with random strengths)\n", " sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05))), # sometimes move parts of the image around\n", " sometimes(iaa.PerspectiveTransform(scale=(0.01, 0.1)))\n", " ],\n", " random_order=True\n", " )\n", " ],\n", " random_order=True\n", ")\n" ] }, { "cell_type": "code", "execution_count": null, "id": "local-sweden", "metadata": {}, "outputs": [], "source": [ "tags = [\"augmented2\"]\n", "label_field = \"ground_truth\"\n", "output_dir = os.path.join(dataset_dir, \"augmented2\")\n", "\n", "aug_samples = []\n", "for sample in dataset.match_tags(\"original\"):\n", " aug_sample = augment_sample(\n", " sample,\n", " label_field,\n", " augmentations2,\n", " output_dir,\n", " tags=tags,\n", " )\n", " aug_samples.append(aug_sample)\n", " \n", "_ = dataset.add_samples(aug_samples)\n" ] }, { "cell_type": "code", "execution_count": 47, "id": "continent-arbor", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", " \n", "
\n", " \n", "
\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "session.view = dataset.match_tags(\"augmented2\")" ] }, { "cell_type": "code", "execution_count": null, "id": "defined-welsh", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "floppy-expression", "metadata": {}, "source": [ "Let's rerun evaluation on the two views of augmented samples and see how the model performs." ] }, { "cell_type": "code", "execution_count": null, "id": "arbitrary-vacuum", "metadata": {}, "outputs": [], "source": [ "aug1_view = dataset.match_tags(\"augmented1\")\n", "aug2_view = dataset.match_tags(\"augmented2\")\n", "\n", "run_inference(aug1_view, model)\n", "run_inference(aug2_view, model)" ] }, { "cell_type": "code", "execution_count": null, "id": "mounted-publisher", "metadata": {}, "outputs": [], "source": [ "from fiftyone import ViewField as F\n", "\n", "# Get high confidence predictions\n", "conf_thresh = 0.5\n", "aug1_view = aug1_view.filter_labels(\"predictions\", F(\"confidence\") > conf_thresh)\n", "aug2_view = aug2_view.filter_labels(\"predictions\", F(\"confidence\") > conf_thresh)" ] }, { "cell_type": "code", "execution_count": 62, "id": "recreational-behalf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating detections...\n", " 100% |███████████████████| 88/88 [1.0s elapsed, 0s remaining, 84.4 samples/s] \n", "Performing IoU sweep...\n", " 100% |███████████████████| 88/88 [641.6ms elapsed, 0s remaining, 137.1 samples/s] \n", "0.2596665720673561\n" ] } ], "source": [ "eval_key_1 = \"aug1_eval\"\n", "results1 = aug1_view.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " eval_key=eval_key_1, \n", " compute_mAP=True,\n", ")\n", "print(results1.mAP())" ] }, { "cell_type": "code", "execution_count": 63, "id": "generic-fireplace", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating detections...\n", " 100% |███████████████████| 80/80 [1.2s elapsed, 0s remaining, 65.0 samples/s] \n", "Performing IoU sweep...\n", " 100% |███████████████████| 80/80 [724.1ms elapsed, 0s remaining, 110.5 samples/s] \n", "0.17284998264006374\n" ] } ], "source": [ "eval_key_2 = \"aug2_eval\"\n", "results2 = aug2_view.evaluate_detections(\n", " \"predictions\", \n", " gt_field=\"ground_truth\", \n", " eval_key=eval_key_2, \n", " compute_mAP=True,\n", ")\n", "print(results2.mAP())" ] }, { "cell_type": "code", "execution_count": null, "id": "automatic-logan", "metadata": {}, "outputs": [], "source": [ "aug1_eval = (\n", " aug1_view\n", " .filter_labels(\"predictions\", (F(eval_key_1) == \"fp\") & (F(\"confidence\") > 0.7))\n", " .filter_labels(\"ground_truth\", F(eval_key_1) == \"fn\", only_matches=False) \n", ")\n", "aug2_eval = (\n", " aug2_view\n", " .filter_labels(\"predictions\", (F(eval_key_2) == \"fp\") & (F(\"confidence\") > 0.7))\n", " .filter_labels(\"ground_truth\", F(eval_key_2) == \"fn\", only_matches=False) \n", ")" ] }, { "cell_type": "code", "execution_count": 77, "id": "destroyed-terrorist", "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.view = aug1_eval" ] }, { "cell_type": "code", "execution_count": null, "id": "polish-identification", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "reasonable-permission", "metadata": {}, "source": [ "Even the basic augmentations show the model having a much harder time detecting dragons and avoiding other objects, especially for small objects." ] }, { "cell_type": "code", "execution_count": 80, "id": "upset-shower", "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.view = aug2_eval" ] }, { "cell_type": "code", "execution_count": null, "id": "hawaiian-elder", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "extreme-conditions", "metadata": {}, "source": [ "While the overall performance on these extremely augmented samples is worse than the un- and slightly-augmented samples, the model still performed somewhat surprisingly well for certain augmentations as you can see above." ] }, { "cell_type": "code", "execution_count": 78, "id": "flush-allergy", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "
\n", "
\n", " \n", "
\n", " \n", "
\n", "\n", "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "session.view = aug2_eval" ] }, { "cell_type": "code", "execution_count": null, "id": "fourth-auckland", "metadata": {}, "outputs": [], "source": [ "session.freeze()" ] }, { "cell_type": "markdown", "id": "wooden-detail", "metadata": {}, "source": [ "An interesting point that jumped out is that the model seems to have difficulties with rotated images indicating that we may want to add that augmentation to the training dataset. We wouldn't want to miss any dragons once we put this model out in the real world just because they are flying upsidedown." ] }, { "cell_type": "markdown", "id": "conceptual-flush", "metadata": {}, "source": [ "## Next Steps\n", "\n", "Based on the observations in the previous sections, we have a plan of action for producing a higher-quality dataset and a higher-performing model.\n", "\n", "* Update the dataset annotations taking into account the wing\n", "\n", "* Incorporate augmentations into the training loop\n", "\n", "* Add more difficult samples like crowds of objects\n", "\n", "* Automate and parameterize the training loop for fast retraining iterations whenever we update the data" ] }, { "cell_type": "markdown", "id": "impossible-david", "metadata": {}, "source": [ "## Summary\n", "\n", "Creating a high-performing model requires much more than just some PyTorch code. Being able to iteratively track and analyze model performance and then use that to inform dataset improvements is necessary for a high-quality model. The combination of the model analysis capabilities of [FiftyOne](https://fiftyone.ai) with the experiment tracking capabilities of [ClearML](https://clear.ml/) results in a system that will lead to better models, faster." ] }, { "cell_type": "markdown", "id": "registered-strain", "metadata": {}, "source": [ "This walkthrough was made in collaboration between the teams at [ClearML](https://clear.ml/) and [Voxel51](https://voxel51.com)." ] } ], "metadata": { "interpreter": { "hash": "98b0a9b7b4eaaa670588a142fd0a9b87eaafe866f1db4228be72b4211d12040f" }, "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": 5 }