docs/predict.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine learning: prediction\n",
    "\n",
    "Machine learning-trained algorithms can predict whether bioacoustic recordings contain a sound of interest. For instance, an algorithm trained how to detect the sound of a Wood Thrush can be used to predict where Wood Thrushes vocalize in a set of autonomous recordings. \n",
    "\n",
    "The Kitzes Lab, the developers of OpenSoundscape, pre-trained a series of [baseline machine learning models](https://pitt.app.box.com/s/3048856qbm9x55yi3zfksa3fide5uuf4) that can be used to predict the presence of [485 species of common North American birds](https://pitt.box.com/s/v0iy8pwctdxaiw9m0xa4a9lnmxv3p30b). These are \"beta\" models; if you are interested in using them for research, please contact us at the [Kitzes Lab](https://kitzeslab.org). Information about the training process is available at this [README](https://pitt.app.box.com/s/6s0ycvbrcxtk2ll6kj7iuhd3kjhufes5).\n",
    "\n",
    "This tutorial downloads an example model and demonstrates how to use it to predict the identity of birds in recordings. To download the tutorial as a Jupyter Notebook, click the \"Edit on GitHub\" button at the top right of the tutorial. To run the Jupyter Notebook tutorial, follow [these instructions](installation.html#installation) to install OpenSoundscape and add the OpenSoundscape environment to your Jupyter kernels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules\n",
    "Import the following modules to run a pre-trained machine learning learning classifier. First, from OpenSoundscape we will need two classes (`Audio` and `SingleTargetAudioDataset`) and three functions (`run_command`, `lowercase_annotations`, and `predict`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from opensoundscape.audio import Audio\n",
    "from opensoundscape.datasets import SingleTargetAudioDataset\n",
    "from opensoundscape.helpers import run_command\n",
    "from opensoundscape.raven import lowercase_annotations\n",
    "from opensoundscape.torch.predict import predict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the following machine learning-related modules. OpenSoundscape uses PyTorch to do machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn\n",
    "import torchvision.models\n",
    "import torch.utils.data\n",
    "import torchvision.transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, use a few miscellaneous functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "import os.path\n",
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "from math import floor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download model\n",
    "\n",
    "To use the model, it must be downloaded onto your computer and loaded with the same specifications it was created with.\n",
    "\n",
    "Download the example model for Wood Thrush, *Hylocichla mustelina*. First, create a folder called `\"prediction_example\"` to store the model and its data in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_name = \"prediction_example\"\n",
    "folder_path = Path(folder_name)\n",
    "if not folder_path.exists(): folder_path.mkdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, download the model from the Box storage site using the following lines. \n",
    "\n",
    "If you prefer, you can also download the model directly off of the shared folder (see introduction paragraphs). Make sure to move it into the `\"prediction_example\"` folder and ensure that it is named `\"hylocichla-mustelina.tar\"`. These instructions can be modified for any of the species included in the pre-trained set of models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_from_box(link, name):\n",
    "    run_command(f\"curl -L {link} -o ./{name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This link format enables direct download."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "link_to_model = \"https://pitt.box.com/shared/static/0xl7aqjlhdrx83am7k4w0e72fsg08dey.tar\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, use the function created above to download the model file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_filename = folder_path.joinpath(\"hylocichla-mustelina.tar\")\n",
    "download_from_box(\n",
    "    link=link_to_model,\n",
    "    name=model_filename,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure that the model was downloaded correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(model_filename.exists())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model\n",
    "At its core, a machine learning model consists of two things: its architecture and its weights. \n",
    "\n",
    "### Create architecture\n",
    "The architecture is the complex structure of the model, which in this case, is a convolutional neural network. Convolutional neural networks are a particular set of algorithms especially suited to extracting and interpreting features from images, such as combinations of lines, dots, and edges. In this case, we use a `resnet18` convolutional neural network. After feature extraction, the convolutional neural network's features are passed to a classifier. The classifier decides how to weight each feature in predicting the final class identity. The model was trained with a `Linear` classifier.\n",
    "\n",
    "Create the architecture of the model. First, designate the model as a `resnet18` CNN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = torchvision.models.resnet18(pretrained=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, add the `fc` layers. \"FC\" stands for \"fully connected\". To set up the proper architecture, we need to specify the correct number of input features, output features, and classifier type. \n",
    "\n",
    "The number of input features to the FC is equal to the number of features extracted from the convolutional neural network and passed to the the FC layer: `model.fc.in_features`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cnn_features = model.fc.in_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The models were trained to predict two classes (species present and species absent), so the number of output features of the FC layer is 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_classes = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the classifier type is a `torch.nn.Linear` classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fc = torch.nn.Linear(\n",
    "    in_features = num_cnn_features,\n",
    "    out_features = num_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load weights and metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The weights of the model are distinguished from its architecture because, while the architecture is decided by humans, the weights of the architecture are learned during the machine learning process.\n",
    "\n",
    "When downloading the machine learning model, you downloaded a compressed file that contains the weights and some metadata about the model. First, inspect what you downloaded using `torch.load` to extract the compressed `.tar` model file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_and_metadata = torch.load(model_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inspect metadata\n",
    "\n",
    "The variable `model_and_metadata` is a dictionary. The keys of the dictionary that we can use to access the model information are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['train_loss', 'train_accuracy', 'train_precision', 'train_recall', 'train_f1', 'train_confusion_matrix', 'valid_accuracy', 'valid_precision', 'valid_recall', 'valid_f1', 'valid_confusion_matrix', 'model_state_dict', 'optimizer_state_dict', 'labels_yaml', 'train_scores', 'train_targets', 'valid_scores', 'valid_targets'])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_and_metadata.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the metadata included in the model is information about the model's performance during training. A full description of what each of these keys means is given in the download folder (see introduction).\n",
    "\n",
    "For instance, the machine learning model is trained using a set of recordings where the species is known to be present, and a set where the species is known to be absent. These files are divided into two sets: a \"training\" set, which the model directly learns from, and a \"validation\" set, which the model does not learn from but we use to check the model's performance as it trains. \n",
    "\n",
    "The model outputs a score for each file. We want the model's scores for the species-present files to be lower than those for the species-absent files. We can inspect the dictionary's `valid_targets` and `valid_scores` attributes, which respectively give a 1 or a 0 based on whether a training file included the species or did not; and a real number score for that file.\n",
    "\n",
    "First, extract the validation score:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_scores = pd.DataFrame(model_and_metadata['valid_scores'])\n",
    "validation_true_targets = pd.Series(model_and_metadata['valid_targets'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, separate the scores for the species-present files and the species-absent files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_absent_scores = validation_scores[validation_true_targets == 0][1]\n",
    "true_present_scores = validation_scores[validation_true_targets == 1][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, plot a histogram of the scores for the two file types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(true_absent_scores, alpha=0.5, label='Species absent')\n",
    "plt.hist(true_present_scores, alpha=0.5, label='Species present')\n",
    "plt.legend()\n",
    "plt.xlabel('Machine learning score')\n",
    "plt.ylabel('Number of files')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model performs fairly well at differentiating the validation files, which are segments of Xeno-Canto recordings. Note: this doesn't mean the model will perform similarly well on ARU recordings!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load weights onto architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use the model itself, access the dictionary's `'model_state_dict'` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights = model_and_metadata['model_state_dict']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, apply these weights to the model architecture created above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_state_dict(weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare prediction files\n",
    "\n",
    "To actually use the model, we need to download and prepare a set of recordings. The model was trained to make predictions on spectrograms made from 5 second-long recordings, so we will have to split the recordings up and transform them into spectrograms.\n",
    "\n",
    "As example data, we have provided a 1 minute-long soundscape which contains Wood Thrush vocalizations. \n",
    "\n",
    "The following code downloads this audio file into the `\"prediction_example\"` folder created above. If you prefer, you can also download this file at [this link](https://pitt.box.com/shared/z73eked7quh1t2pp93axzrrpq6wwydx0). Make sure to move it into the `\"prediction_example\"` folder and ensure that it is named `\"1min.wav\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_filename = folder_path.joinpath(\"1minexamplefile.wav\")\n",
    "download_from_box(\n",
    "    link = \"https://pitt.box.com/shared/static/z73eked7quh1t2pp93axzrrpq6wwydx0.wav\",\n",
    "    name = data_filename\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example soundscape must be split up into soundscapes of the same size as the ones the model was trained on. In this case, the soundscapes should be 5s long.\n",
    "\n",
    "First, create a directory in which to save split files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_directory = folder_path.joinpath(\"split_files\")\n",
    "if not split_directory.exists(): split_directory.mkdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, load the 1-minute long file as an `Audio` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_file = Audio.from_file(data_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To split `base_file` into 5s long segments, use the `split` method of `opensoundscape.Audio`. This will return a list of dictionaries, containing a 5s long `Audio` object, and its start time and end time with respect to `base_file`. The argument `final_clip=None` only makes a difference if the source audio didn't have a length divisible by 5s, by removing the remainder clip so that we are only left with 5s long clips. For more information on the behavior of this argument, see the API Documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "split_files = base_file.split(\n",
    "    clip_duration=5,\n",
    "    clip_overlap=0,\n",
    "    final_clip=None,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See what the first element of the resulting array looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'clip': <Audio(samples=(160000,), sample_rate=32000)>,\n",
       " 'clip_duration': 5.0,\n",
       " 'begin_time': 0,\n",
       " 'end_time': 5}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split_files[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save each of these split files in the directory created earlier. Save each of them with a prefix and the start and end times of the split with respect to the original file. In this case, make the prefix equal to the filename of the base file, without the extension (its stem):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1minexamplefile'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split_prefix = data_filename.stem\n",
    "split_prefix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following loop saves each of the clips in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames = []\n",
    "for split_file_dict in split_files:\n",
    "    # Extract the Audio object\n",
    "    clip_audio = split_file_dict['clip']\n",
    "    \n",
    "    # The start and end time of this clip with respect to the original recording\n",
    "    begin_time = split_file_dict['begin_time']\n",
    "    end_time = split_file_dict['end_time']\n",
    "    \n",
    "    # Create a filename that starts with the filename of the original recording\n",
    "    filename = split_directory.joinpath(f'{split_prefix}_{begin_time}s-{end_time}s.wav')\n",
    "    \n",
    "    # Keep track of the filenames in an array\n",
    "    filenames.append(filename)\n",
    "    \n",
    "    # Save the filenames\n",
    "    clip_audio.save(path=filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a Dataset\n",
    "\n",
    "Now that the data are split, we can create a \"dataset\" from them using OpenSoundscape's `SingleTargetAudioDataset`.  This structure takes in a `DataFrame` of filenames. It can be accessed like a list of the same length as the DataFrame of filenames. When it is accessed, it takes the filename, loads the audio at the filename, and transforms that audio into a spectrogram in the correct format to use for our machine learning models.\n",
    "\n",
    "This dataset, `SingleTargetAudioDataset`, is intended for models that predict the presence of a single target, e.g., models that predict whether a single species is present in a file, like the model we are using. It can be used in both training and prediction, and has many options for implementing image augmentation during training (see the API Documentation). Just use the default options for prediction.\n",
    "\n",
    "To create a dataset, first format the list of 5s clip filenames into a pandas `DataFrame`. Name the column containing the filenames `'file_path'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename_column = 'file_path'\n",
    "files_to_predict_on = pd.DataFrame(filenames, columns=[filename_column])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, the `SingleTargetAudioDataset` requires that we use a dictionary that associates numeric labels with the class names: 1 is for predicting a Wood Thrush's presence; 0 is for predicting a Wood Thrush's absence. This dictionary is packaged with the model under the key `'labels_yaml'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'hylocichla-mustelina-absent', 1: 'hylocichla-mustelina-present'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_dict = yaml.safe_load(model_and_metadata['labels_yaml'])\n",
    "label_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now create the `SingleTargetAudioDataset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = SingleTargetAudioDataset(\n",
    "    df=files_to_predict_on,\n",
    "    filename_column=filename_column,\n",
    "    label_dict=label_dict,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `test_dataset` is a list of dictionaries. Each element of the list contains a dictionary for one of the files to predict on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each dictionary in `test_dataset` has one or two keys. In all cases, the dictionary has a key `'X'` which refers to the spectrogram. If a dataset is created with true labels, the dictionary also has a `'y'` key which links to the true label. Because it is unknown which of these files contain Wood Thrush songs, no true labels were given when creating the dataset.\n",
    "\n",
    "The spectrogram itself is stored as a PyTorch tensor. For example, here is the tensor of the first spectrogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         ...,\n",
       "         [-0.2314, -0.1451,  0.1373,  ..., -0.0902, -0.1373, -0.0902],\n",
       "         [-0.1529, -0.2157,  0.1922,  ..., -0.1451, -0.1686, -0.0275],\n",
       "         [ 0.2784,  0.0275,  0.3647,  ...,  0.0510,  0.1059,  0.3176]],\n",
       "\n",
       "        [[ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         ...,\n",
       "         [-0.2314, -0.1451,  0.1373,  ..., -0.0902, -0.1373, -0.0902],\n",
       "         [-0.1529, -0.2157,  0.1922,  ..., -0.1451, -0.1686, -0.0275],\n",
       "         [ 0.2784,  0.0275,  0.3647,  ...,  0.0510,  0.1059,  0.3176]],\n",
       "\n",
       "        [[ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         [ 1.0000,  1.0000,  1.0000,  ...,  1.0000,  1.0000,  1.0000],\n",
       "         ...,\n",
       "         [-0.2314, -0.1451,  0.1373,  ..., -0.0902, -0.1373, -0.0902],\n",
       "         [-0.1529, -0.2157,  0.1922,  ..., -0.1451, -0.1686, -0.0275],\n",
       "         [ 0.2784,  0.0275,  0.3647,  ...,  0.0510,  0.1059,  0.3176]]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_tensor = test_dataset[0]['X']\n",
    "first_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To view this spectrogram, use PyTorch's `transforms.ToPILImage()` function. This function returns a transformer. Call the transformer on the first tensor to display the spectrogram as an image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=224x224 at 0x1405BA208>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = torchvision.transforms.ToPILImage()\n",
    "transformer(first_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use model on prediction files\n",
    "\n",
    "Finally, the model can be used for prediction. Use OpenSoundscape's `predict` function to call the model on the test dataset. The `label_dict` created above is used to make the classes interpretable; otherwise, the classes would just be numbered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hylocichla-mustelina-absent</th>\n",
       "      <th>hylocichla-mustelina-present</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_0s-5s.wav</th>\n",
       "      <td>-2.699836</td>\n",
       "      <td>2.345755</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_5s-10s.wav</th>\n",
       "      <td>-3.972310</td>\n",
       "      <td>4.026467</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_10s-15s.wav</th>\n",
       "      <td>-5.235929</td>\n",
       "      <td>5.631192</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_15s-20s.wav</th>\n",
       "      <td>-2.984634</td>\n",
       "      <td>2.917254</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_20s-25s.wav</th>\n",
       "      <td>-1.895094</td>\n",
       "      <td>2.359997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_25s-30s.wav</th>\n",
       "      <td>-3.669389</td>\n",
       "      <td>4.548790</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_30s-35s.wav</th>\n",
       "      <td>-3.804515</td>\n",
       "      <td>4.256460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_35s-40s.wav</th>\n",
       "      <td>-4.488552</td>\n",
       "      <td>4.726258</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_40s-45s.wav</th>\n",
       "      <td>-3.719126</td>\n",
       "      <td>3.582299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_45s-50s.wav</th>\n",
       "      <td>-4.844445</td>\n",
       "      <td>4.841421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_50s-55s.wav</th>\n",
       "      <td>-3.637188</td>\n",
       "      <td>3.066844</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>prediction_example/split_files/1minexamplefile_55s-60s.wav</th>\n",
       "      <td>-3.639840</td>\n",
       "      <td>3.178823</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    hylocichla-mustelina-absent  \\\n",
       "prediction_example/split_files/1minexamplefile_...                    -2.699836   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.972310   \n",
       "prediction_example/split_files/1minexamplefile_...                    -5.235929   \n",
       "prediction_example/split_files/1minexamplefile_...                    -2.984634   \n",
       "prediction_example/split_files/1minexamplefile_...                    -1.895094   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.669389   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.804515   \n",
       "prediction_example/split_files/1minexamplefile_...                    -4.488552   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.719126   \n",
       "prediction_example/split_files/1minexamplefile_...                    -4.844445   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.637188   \n",
       "prediction_example/split_files/1minexamplefile_...                    -3.639840   \n",
       "\n",
       "                                                    hylocichla-mustelina-present  \n",
       "prediction_example/split_files/1minexamplefile_...                      2.345755  \n",
       "prediction_example/split_files/1minexamplefile_...                      4.026467  \n",
       "prediction_example/split_files/1minexamplefile_...                      5.631192  \n",
       "prediction_example/split_files/1minexamplefile_...                      2.917254  \n",
       "prediction_example/split_files/1minexamplefile_...                      2.359997  \n",
       "prediction_example/split_files/1minexamplefile_...                      4.548790  \n",
       "prediction_example/split_files/1minexamplefile_...                      4.256460  \n",
       "prediction_example/split_files/1minexamplefile_...                      4.726258  \n",
       "prediction_example/split_files/1minexamplefile_...                      3.582299  \n",
       "prediction_example/split_files/1minexamplefile_...                      4.841421  \n",
       "prediction_example/split_files/1minexamplefile_...                      3.066844  \n",
       "prediction_example/split_files/1minexamplefile_...                      3.178823  "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_df = predict(model, test_dataset, label_dict=label_dict)\n",
    "prediction_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpreting these scores is the challenging part of machine learning. One typical method is to empirically determine a score threshold below which the species is considered absent and present, and listen to a sample of recordings above and below the threshold to determine the false positive and false negative rate of the threshold. \n",
    "\n",
    "Note that the classifier usually performs worse on autonomous recording unit data than it does on the validation set. In particular, the distributions of the species-present and species-absent values may have greater variance and may be centered on different values, closer to each other than in the validation set (see histograms above)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, this command \"cleans up\" by deleting all the downloaded files and results. Only run this if you are ready to remove the results of this analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "shutil.rmtree(folder_path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "OpenSoundscape",
   "language": "python",
   "name": "opensoundscape-dxmth98s-py3.7"
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}