{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Train classifiers on BirdNET or Perch embeddings\n",
                "\n",
                "\n",
                "> NOTE: The primary class for transfer learning is now SongSpace. Please see the SongSpace tutorial notebook for a demonstration of the workflow to embed samples to a database and train shallow classifiers. Direct use of the APIs demonstrated in this notebook is for advanced useres.\n",
                "\n",
                "This notebook shows examples of how to train simple one-layer or multi-layer fully-connected neural networks (aka multi-layer perceptron networks, MLPs) on Perch [1] and BirdNET [2], which are TensorFlow models. For a more general introduction to transfer learning tools in OpenSoundscape see the `transfer_learning.ipynb` notebook, which focuses on PyTorch (rather than Tensorflow) embedding models. \n",
                "\n",
                "Though BirdNET and Perch are TensorFlow models, we can still use them as feature extractors (to generate embeddings) and train shallow classifiers on top of them with PyTorch. We just won't be able to train the feature extractor weights at all. \n",
                "\n",
                "For this notebook, you'll need a Python environment with `tensorflow` and `tensorflow-hub` packages installed. If you want cuda gpu acceleration on a linux machine, check this [table](https://www.tensorflow.org/install/source#gpu) for the `tensorflow` and `cudnn` package versions you'll need to be compatible with your current CUDA version (you can check the cuda version on your machine by calling `nvidia-smi` from command line). Note that the `cudnn` package version might conflict with which version PyTorch wants, so we recommend creating separate Python environments for pytorch and tensorflow cuda-compatability. \n",
                "\n",
                "Note that in this tutorial, all classifiers are trained as multi-target (each class is predicted independently, such that any sample can have 0, 1, or >1 classes present). Most bioacoustics classification tasks are multi-target. \n",
                "\n",
                "## preparing your python environment\n",
                "This notebook uses the [bioacoustics_model_zoo](https://github.com/kitzeslab/bioacoustics-model-zoo), so you'll want to install that repository as a package in your python environment. After installing, be sure to restart this notebook's kernel so that the model zoo is available. From command line, you can install the model zoo from github using\n",
                "\n",
                "`pip install bioacoustics-model-zoo==0.12.0`\n",
                "\n",
                "If you want a specific version (aka tag or release) of the model zoo, you can specify it after an @ symbol:\n",
                "\n",
                "`pip install bioacoustics-model-zoo==0.12.0@0.11.0.dev1`\n",
                "\n",
                "\n",
                "> [1] Ghani, B., T. Denton, S. Kahl, H. Klinck, T. Denton, S. Kahl, and H. Klinck. 2023. Global birdsong embeddings enable superior transfer learning for bioacoustic classification. Scientific Reports 13:22876.\n",
                ">\n",
                "> [2] Kahl, Stefan, et al. \"BirdNET: A deep learning solution for avian diversity monitoring.\" Ecological Informatics 61 (2021): 101236.\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Run this tutorial\n",
                "\n",
                "This tutorial is more than a reference! It's a Jupyter Notebook which you can run and modify on Google Colab or your own computer.\n",
                "\n",
                "|Link to tutorial|How to run tutorial|\n",
                "| :- | :- |\n",
                "| [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/kitzeslab/opensoundscape/blob/master/docs/tutorials/train_cnn.ipynb) | The link opens the tutorial in Google Colab. Uncomment the \"installation\" line in the first cell to install OpenSoundscape. |\n",
                "| [![Download via DownGit](https://img.shields.io/badge/GitHub-Download-teal?logo=github)](https://minhaskamal.github.io/DownGit/#/home?url=https://github.com/kitzeslab/opensoundscape/blob/master/docs/tutorials/train_birdnet_and_perch.ipynb) | The link downloads the tutorial file to your computer. Follow the [Jupyter installation instructions](https://opensoundscape.org/en/latest/installation/jupyter.html), then open the tutorial file in Jupyter. |"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "%load_ext autoreload\n",
                "%autoreload 2"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [],
            "source": [
                "# if this is a Google Colab notebook, install opensoundscape in the runtime environment\n",
                "if 'google.colab' in str(get_ipython()):\n",
                "  %pip install \"opensoundscape==0.13.1\" \"jupyter-client<8,>=5.3.4\" \"ipykernel==6.17.1\" \"bioacoustics-model-zoo==0.12.0\"\n",
                "  num_workers=0\n",
                "else:\n",
                "  num_workers=4"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Setup"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Import needed packages"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/var/folders/d8/265wdp1n0bn_r85dh3pp95fh0000gq/T/ipykernel_44889/3183818291.py:10: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
                        "  from tqdm.autonotebook import tqdm\n"
                    ]
                }
            ],
            "source": [
                "import torch\n",
                "import pandas as pd\n",
                "from pathlib import Path\n",
                "import numpy as np\n",
                "import pandas as pd\n",
                "import random \n",
                "from glob import glob\n",
                "import sklearn\n",
                "\n",
                "from tqdm.autonotebook import tqdm\n",
                "from sklearn.metrics import average_precision_score, roc_auc_score\n",
                "from pathlib import Path\n",
                "\n",
                "#set up plotting\n",
                "from matplotlib import pyplot as plt\n",
                "plt.rcParams['figure.figsize']=[15,5] #for large visuals\n",
                "%config InlineBackend.figure_format = 'retina'\n",
                "\n",
                "# opensoundscape transfer learning tools\n",
                "from opensoundscape.ml.shallow_classifier import MLPClassifier, fit_classifier_on_embeddings\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Set random seeds\n",
                "\n",
                "Set manual seeds for Pytorch and Python. These essentially \"fix\" the results of any stochastic steps in model training, ensuring that training results are reproducible. You probably don't want to do this when you actually train your model, but it's useful for debugging."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "torch.manual_seed(0)\n",
                "random.seed(0)\n",
                "np.random.seed(0)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Download and prepare training data\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Download example files\n",
                "Download a set of aquatic soundscape recordings with annotations of _Rana sierrae_ vocalizations. If you already have them, you can skip this step. \n",
                "\n",
                "Option 1: run the cell below\n",
                "\n",
                "- if you get a 403 error, DataDryad suspects you are a bot. Use Option 2. \n",
                "\n",
                "Option 2:\n",
                "\n",
                "- Download and unzip the `rana_sierrae_2022.zip` folder containing audio and annotations from this [public Dryad dataset](https://datadryad.org/stash/dataset/doi:10.5061/dryad.9s4mw6mn3#readme)\n",
                "- Move the unzipped `rana_sierrae_2022` folder into the current folder"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "zsh:1: command not found: wget\n",
                        "Archive:  rana_sierrae_2022.zip\n",
                        "  End-of-central-directory signature not found.  Either this file is not\n",
                        "  a zipfile, or it constitutes one disk of a multi-part archive.  In the\n",
                        "  latter case the central directory and zipfile comment will be found on\n",
                        "  the last disk(s) of this archive.\n",
                        "Archive:  rana_sierrae_2022.ZIP\n",
                        "  End-of-central-directory signature not found.  Either this file is not\n",
                        "  a zipfile, or it constitutes one disk of a multi-part archive.  In the\n",
                        "  latter case the central directory and zipfile comment will be found on\n",
                        "  the last disk(s) of this archive.\n"
                    ]
                }
            ],
            "source": [
                "# Note: the \"!\" preceding each line below allows us to run bash commands in a Jupyter notebook\n",
                "# If you are not running this code in a notebook, input these commands into your terminal instead\n",
                "!wget -O rana_sierrae_2022.zip https://datadryad.org/stash/downloads/file_stream/2722802;\n",
                "!unzip rana_sierrae_2022;"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Prepare audio data\n",
                "See the train_cnn.ipynb tutorial for step-by-step walkthrough of this process, or just run the cells below to prepare a trainig set."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/SML161/opensoundscape/opensoundscape/annotations.py:347: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
                        "  all_annotations_df = pd.concat(all_file_dfs).reset_index(drop=True)\n"
                    ]
                }
            ],
            "source": [
                "# Set the current directory to where the folder `rana_sierrae_2022` is located:\n",
                "dataset_path = Path(\"./rana_sierrae_2022/\")\n",
                "\n",
                "# let's generate clip labels of 5s duration (to match Perch input duration) using the raven annotations\n",
                "# and some utility functions from opensoundscape\n",
                "from opensoundscape.annotations import BoxedAnnotations\n",
                "\n",
                "audio_and_raven_files = pd.read_csv(f\"{dataset_path}/audio_and_raven_files.csv\")\n",
                "# update the paths to where we have the audio and raven files stored\n",
                "audio_and_raven_files[\"audio\"] = audio_and_raven_files[\"audio\"].apply(\n",
                "    lambda x: f\"{dataset_path}/{x}\"\n",
                ")\n",
                "audio_and_raven_files[\"raven\"] = audio_and_raven_files[\"raven\"].apply(\n",
                "    lambda x: f\"{dataset_path}/{x}\"\n",
                ")\n",
                "\n",
                "annotations = BoxedAnnotations.from_raven_files(\n",
                "    raven_files=audio_and_raven_files[\"raven\"],\n",
                "    audio_files=audio_and_raven_files[\"audio\"],\n",
                "    annotation_column=\"annotation\",\n",
                ")\n",
                "# generate labels for 5s clips, including any labels that overlap by at least 0.2 seconds\n",
                "labels = annotations.clip_labels(clip_duration=3, min_label_overlap=0.2)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Inspect labels\n",
                "\n",
                "Count number of each annotation type: \n",
                "\n",
                "Note that the 'X' label is for when the annotator was uncertain about the identity of a call. Labels A-E denote distinct call types."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "A    675\n",
                            "E    180\n",
                            "D     65\n",
                            "B     32\n",
                            "C    110\n",
                            "X    133\n",
                            "dtype: int64"
                        ]
                    },
                    "execution_count": 4,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "labels.sum()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### split into training and validation data\n",
                "We'll just focus on class 'A', the call type with the most annotations. We'll randomly split the clips into training and validation data, acknowledging that this approach does not test the ability of the model to generalize. Since the samples in the training and validation sets could be adjascent 2-second audio clips, good performance could simply mean the model has memorized the training samples, and the validation set has very similar samples. "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [],
            "source": [
                "classes = [\"A\"]\n",
                "labels_train, labels_val = sklearn.model_selection.train_test_split(labels[classes])"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Train classification head on BirdNET\n",
                "\n",
                "The BirdNET and Perch models provided in the Bioacoustics Model Zoo have a `.tf_model` attribute containing the TensorFlow inference model and a `.network` attribute containing a trainable PyTorch classification head, specifically an instance of the MLPCLassifier class. To train a custom classifier on the embeddings extracted by these models, we just need to (1) embed the training and validation samples, then (2) pass the embeddings and labels to the `.network.fit()` method. \n",
                "\n",
                "This is equivalent to passing the `.network` to the the `opensoundscape.ml.shallow_classifier.fit()` method, so you can also experiment with generating your own classification heads (e.g. various instances of MLPClassifier) and fitting each of them on the embeddings. See the transfer learning tutorial for further examples. "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### First, get BirdNET from the Bioacoustics Model Zoo"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [],
            "source": [
                "import bioacoustics_model_zoo as bmz\n",
                "\n",
                "birdnet = bmz.BirdNET()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Second, generate embeddings on the training and validation samples\n",
                "\n",
                "In general, generating embeddings will take a bit of time (because it requires loading, preprocessing, and embedding samples) but training shallow classifiers will be fast. "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/SML161/opensoundscape/opensoundscape/ml/cnn.py:2928: UserWarning: The columns of input samples df differ from `model.classes`. Discarding sample df columns.\n",
                        "  warnings.warn(\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "ff2658bf2de34c73977d663d88a5d9b0",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/63 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/SML161/opensoundscape/opensoundscape/ml/cnn.py:2928: UserWarning: The columns of input samples df differ from `model.classes`. Discarding sample df columns.\n",
                        "  warnings.warn(\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "0fd69be4c8f745e6800596f6fa5593e9",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/21 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "emb_train = birdnet.embed(\n",
                "    labels_train, return_dfs=False, batch_size=32, num_workers=num_workers\n",
                ")\n",
                "emb_val = birdnet.embed(\n",
                "    labels_val, return_dfs=False, batch_size=32, num_workers=num_workers\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Third, fit the shallow classifier on the desired classes"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Step 100/300, Loss: 0.282, Val Loss: 0.299, val AU ROC: 0.937, val MAP: 0.835\n",
                        "Step 200/300, Loss: 0.364, Val Loss: 0.273, val AU ROC: 0.943, val MAP: 0.846\n",
                        "Step 300/300, Loss: 0.215, Val Loss: 0.263, val AU ROC: 0.943, val MAP: 0.846\n",
                        "Loaded best model with validation loss: 0.263 at step 297 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.26286981006463367,\n",
                            " 'auroc': 0.9430248414062963,\n",
                            " 'map': 0.8463308946562795,\n",
                            " 'per_class_auroc': [0.9430248414062963]}"
                        ]
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# We want to train the classifier on the 'A' class here, corresponding to the primary R. sierrae call type.\n",
                "# Let's replace fc output layer with 1-output layer for class 'A'\n",
                "\n",
                "birdnet.change_classes(classes)\n",
                "\n",
                "# fit the classification head with embeddings and labels\n",
                "best_step_metrics = birdnet.network.fit(\n",
                "    emb_train, labels_train.values, emb_val, labels_val.values, steps=300\n",
                ")\n",
                "best_step_metrics"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Fourth, evaluate the classifier on the validation set"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "ROC AUC Score: 0.943\n"
                    ]
                }
            ],
            "source": [
                "# make predictions by passing the embeddings through the classifier\n",
                "preds = birdnet.network(torch.tensor(emb_val)).detach()\n",
                "# calculate the area under the ROC score\n",
                "print(f\"ROC AUC Score: {roc_auc_score(labels_val.values, preds, average=None):.3f}\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "to visualize the performance, let's plot histograms of classifier logit scores for positive and negative samples\n",
                "\n",
                "it shows that precision is ok for scores above 2 (few negatives get high scores), but recall is only moderate (many positive samples get low scores)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "<matplotlib.legend.Legend at 0x341b170e0>"
                        ]
                    },
                    "execution_count": 13,
                    "metadata": {},
                    "output_type": "execute_result"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1500x500 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "image/png": {
                            "height": 428,
                            "width": 1209
                        }
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "preds = preds.detach().numpy()\n",
                "plt.hist(preds[labels_val == True], bins=20, alpha=0.5, label=\"positives\")\n",
                "plt.hist(preds[labels_val == False], bins=20, alpha=0.5, label=\"negatives\")\n",
                "plt.legend()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Saving and loading custom classifiers\n",
                "We use the BirdNET.save_classifier(path) and BirdNET.load_classifier(path) functions to save and load custom classification heads (MLPClassifier objects)."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [],
            "source": [
                "# save the MLP Classifier (birdnet.network or alias birdnet.classifier) to a file\n",
                "birdnet.classifier.save(\"custom_birdnet_classifier.pth\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Load and use the custom classifier"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "f34ece604e854ca09a81c3527dda8fe2",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/5 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "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></th>\n",
                            "      <th></th>\n",
                            "      <th>A</th>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>file</th>\n",
                            "      <th>start_time</th>\n",
                            "      <th>end_time</th>\n",
                            "      <th></th>\n",
                            "    </tr>\n",
                            "  </thead>\n",
                            "  <tbody>\n",
                            "    <tr>\n",
                            "      <th>rana_sierrae_2022/mp3/sine2022a_MSD-0558_20220624_173000_0-10s.mp3</th>\n",
                            "      <th>0.0</th>\n",
                            "      <th>3.0</th>\n",
                            "      <td>NaN</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>rana_sierrae_2022/mp3/sine2022a_MSD-0558_20220620_093000_0-10s.mp3</th>\n",
                            "      <th>3.0</th>\n",
                            "      <th>6.0</th>\n",
                            "      <td>NaN</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>rana_sierrae_2022/mp3/sine2022a_MSD-0558_20220624_091500_0-10s.mp3</th>\n",
                            "      <th>9.0</th>\n",
                            "      <th>12.0</th>\n",
                            "      <td>NaN</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>rana_sierrae_2022/mp3/sine2022a_MSD-0558_20220624_010000_0-10s.mp3</th>\n",
                            "      <th>3.0</th>\n",
                            "      <th>6.0</th>\n",
                            "      <td>NaN</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>rana_sierrae_2022/mp3/sine2022a_MSD-0558_20220621_140000_0-10s.mp3</th>\n",
                            "      <th>6.0</th>\n",
                            "      <th>9.0</th>\n",
                            "      <td>NaN</td>\n",
                            "    </tr>\n",
                            "  </tbody>\n",
                            "</table>\n",
                            "</div>"
                        ],
                        "text/plain": [
                            "                                                                          A\n",
                            "file                                               start_time end_time     \n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 0.0        3.0       NaN\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 3.0        6.0       NaN\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 9.0        12.0      NaN\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 3.0        6.0       NaN\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 6.0        9.0       NaN"
                        ]
                    },
                    "execution_count": 15,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# load custom classifier onto BirdNET\n",
                "birdnet.classifier = MLPClassifier.load(\"custom_birdnet_classifier.pth\")\n",
                "\n",
                "# apply BirdNET with custom classifier\n",
                "birdnet.predict(labels_val.head())"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Note that we could also directly load and use the classifier on embeddings"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 16,
            "metadata": {},
            "outputs": [],
            "source": [
                "mlp_classifier = MLPClassifier.load(\"custom_birdnet_classifier.pth\")\n",
                "prediction_scores = mlp_classifier(torch.tensor(emb_val)).detach()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### simplifying training into a single function call\n",
                "\n",
                "We can use the .train() function to combine these steps into one line of code: the function first creates embeddings, then fits the shallow classifier using the embeddings and the labels. It also reports performance on the validation set. This function is designed to look very similar to the Opensoundscape.CNN.train() method, but note that it is doing something different: it begins by creating embeddings using the pre-trained model, and only trains the classification head, not the entire model architecture (the feature extraction layers remain unchanged). \n",
                "\n",
                "The advantage of taking each step separately (as shown above) is that once we create the embeddings, we can rapidly try fitting different shallow classifiers."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the training samples without augmentation\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "69e39c55e70f442fa08098114aa6d05e",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/1 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the validation samples\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "f0c4e88bb0ae423a8f28b00621529cc7",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/1 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Fitting the classifier\n",
                        "Step 100/1000, Loss: 0.120, Val Loss: 0.386, val AU ROC: 0.914, val MAP: 0.775\n",
                        "Step 200/1000, Loss: 0.052, Val Loss: 0.427, val AU ROC: 0.908, val MAP: 0.767\n",
                        "Step 300/1000, Loss: 0.030, Val Loss: 0.465, val AU ROC: 0.903, val MAP: 0.760\n",
                        "Step 400/1000, Loss: 0.020, Val Loss: 0.496, val AU ROC: 0.903, val MAP: 0.760\n",
                        "Step 500/1000, Loss: 0.014, Val Loss: 0.523, val AU ROC: 0.901, val MAP: 0.759\n",
                        "Step 600/1000, Loss: 0.011, Val Loss: 0.546, val AU ROC: 0.900, val MAP: 0.758\n",
                        "Step 700/1000, Loss: 0.008, Val Loss: 0.566, val AU ROC: 0.900, val MAP: 0.758\n",
                        "Step 800/1000, Loss: 0.007, Val Loss: 0.584, val AU ROC: 0.900, val MAP: 0.758\n",
                        "Step 900/1000, Loss: 0.006, Val Loss: 0.600, val AU ROC: 0.899, val MAP: 0.758\n",
                        "Step 1000/1000, Loss: 0.005, Val Loss: 0.615, val AU ROC: 0.897, val MAP: 0.757\n",
                        "Loaded best model with validation loss: 0.379 at step 73 of 1000\n",
                        "Training complete\n"
                    ]
                }
            ],
            "source": [
                "birdnet.change_classes(classes)\n",
                "# we demonstrate on a smaller subset of data for efficiency:\n",
                "birdnet.train(\n",
                "    train_df=labels_train.sample(64),\n",
                "    validation_df=labels_val.sample(64),\n",
                "    embedding_batch_size=64,\n",
                "    embedding_num_workers=num_workers,\n",
                "    steps=1000,\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### adjusting the shallow classifier architecture\n",
                "By default, we are training a single fully-connected neural network layer to map from the embeddings (feature vectors) to the class predictions, which is equivalent to logistic regression. We can easily modify the structure of the shallow classifier to a multi-layer network. For instance, let's make a 2-layer artificial neural network with a hidden layer of size (100,):"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Step 100/300, Loss: 0.223, Val Loss: 0.251, val AU ROC: 0.944, val MAP: 0.853\n",
                        "Step 200/300, Loss: 0.295, Val Loss: 0.264, val AU ROC: 0.942, val MAP: 0.854\n",
                        "Step 300/300, Loss: 0.187, Val Loss: 0.257, val AU ROC: 0.942, val MAP: 0.852\n",
                        "Loaded best model with validation loss: 0.238 at step 183 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.23786325504382452,\n",
                            " 'auroc': 0.9419339538744294,\n",
                            " 'map': 0.8520296699222578,\n",
                            " 'per_class_auroc': [0.9419339538744294]}"
                        ]
                    },
                    "execution_count": 18,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# replace the classification head with a 2-layer MLP (2 fully-connected layers)\n",
                "birdnet.initialize_custom_classifier(classes, hidden_layer_sizes=[100])\n",
                "\n",
                "# since we already computed the embeddings, we can directly fit the classifier\n",
                "from opensoundscape.ml.shallow_classifier import fit\n",
                "\n",
                "fit(\n",
                "    birdnet.classifier,\n",
                "    emb_train,\n",
                "    labels_train.values,\n",
                "    emb_val,\n",
                "    labels_val.values,\n",
                "    steps=300,\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "when we evaluate, we see that the performance of our two-layer classificaiton head on the validation set is slightly _worse_ than we got with a 1-layer classification head. This indicates that the two-layer model was over-parameterized, and was able to over-fit to the training data leading to worse generalization to the validation set. "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 19,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "auc roc score: 0.9419339538744294\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "<matplotlib.legend.Legend at 0x341fbe710>"
                        ]
                    },
                    "execution_count": 19,
                    "metadata": {},
                    "output_type": "execute_result"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1500x500 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "image/png": {
                            "height": 428,
                            "width": 1209
                        }
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# make predictions by passing the embeddings through the classifier\n",
                "preds = birdnet.network(torch.tensor(emb_val)).detach()\n",
                "# calculate the area under the ROC score\n",
                "print(f\"auc roc score: {roc_auc_score(labels_val.values, preds, average=None)}\")\n",
                "\n",
                "# plot histograms\n",
                "preds = preds.detach().numpy()\n",
                "plt.hist(preds[labels_val == True], bins=20, alpha=0.5, label=\"positives\")\n",
                "plt.hist(preds[labels_val == False], bins=20, alpha=0.5, label=\"negatives\")\n",
                "plt.legend()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### including variants of the training samples using augmentation\n",
                "Augmentation is a powerful technique for avoiding over-fitting and helping machine learning models generalize. The .predict() function gives us an option to perform stochastic augmentations of the training samples, thereby creating variations of the embeddings to increase the effective size of our training data. We use the `n_augmentation_variants` parameter to choose the number of variations: by default this parameter is 0 and no augmentation is performed. Here we choose to create 2 variations of each training sample using augmentation - in practice, it may be helpful to create 8 or more variations of each training sample, but note that the time to create the embeddings will be proportional to the number of variations you create. \n",
                "\n",
                "We use a subset (.sample(20)) of audio clips here for the sake of demonstration. Each of the 20 samples generates 2 training sample variants via augmentation."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 20,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "9503ee869da44daabf563ea1cf95029e",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/2 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Step 100/300, Loss: 0.088, Val Loss: 0.532, val AU ROC: 0.830, val MAP: 0.615\n",
                        "Step 200/300, Loss: 0.036, Val Loss: 0.606, val AU ROC: 0.842, val MAP: 0.638\n",
                        "Step 300/300, Loss: 0.020, Val Loss: 0.669, val AU ROC: 0.845, val MAP: 0.646\n",
                        "Loaded best model with validation loss: 0.482 at step 36 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.48232094446818036,\n",
                            " 'auroc': 0.8452955475188237,\n",
                            " 'map': 0.6459689462528613,\n",
                            " 'per_class_auroc': [0.8452955475188237]}"
                        ]
                    },
                    "execution_count": 20,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# revert to a 1-layer classification head\n",
                "from opensoundscape.ml import shallow_classifier\n",
                "\n",
                "birdnet.initialize_custom_classifier(hidden_layer_sizes=[], classes=classes)\n",
                "# create augmented embeddings\n",
                "train_emb, train_labels = shallow_classifier.augmented_embed(\n",
                "    birdnet, labels_train.sample(20), n_augmentation_variants=2, batch_size=16\n",
                ")\n",
                "\n",
                "\n",
                "# fit the classifier\n",
                "birdnet.network.fit(train_emb, train_labels, emb_val, labels_val, steps=300)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Train shallow classifier on Perch2 embeddings\n",
                "\n",
                "Training classifiers on Perch or Perch2 works the same way!\n",
                "\n",
                "Since Perch2 uses 5 second audio clips as inputs, we'll first re-generate clip labels for 5 second audio segments from the annotated _Rana sierrae_ dataset. \n",
                "\n",
                "As before, well just work on the 'A' type call for this example"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "As with BirdNET (see examples above): \n",
                "\n",
                "- our `perch` model object with the custom classification head (which is an instance of the Perch class) can be saved with `perch.save(path)` and loaded with `reloaded_model=Perch.load(path)`.\n",
                "\n",
                "- we could perform the embedding and classifier fitting steps separately using `perch.embed(labels_val,...)` to create embeddings, then fit with `perch.network.fit(emb_train, labels_train.values, emb_val, labels_val.values)`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "labels = annotations.clip_labels(clip_duration=5, min_label_overlap=0.2)\n",
                "labels_train, labels_val = sklearn.model_selection.train_test_split(labels[[\"A\"]])"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Step 1: Get the Perch model from the Biaocoustics Model Zoo"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/SML161/miniconda3/envs/opso_dev/lib/python3.13/site-packages/tensorflow_hub/__init__.py:61: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n",
                        "  from pkg_resources import parse_version\n",
                        "/Users/SML161/miniconda3/envs/opso_dev/lib/python3.13/site-packages/bioacoustics_model_zoo/perch_v2.py:215: UserWarning: Disabling TensorFlow's XLA compilation (setting tf.config.optimizer.set_jit(False)) because otherwise TF models on Mac hang at runtime as of Tensorflow 2.21.0\n",
                        "  warnings.warn(\n"
                    ]
                }
            ],
            "source": [
                "import bioacoustics_model_zoo as bmz\n",
                "\n",
                "perch2 = bmz.Perch2()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Step 2: Train the shallow classifier on embeddings from the pre-trained model\n",
                "\n",
                "We set up a 2-layer classification head (see details above) by running `initialize_custom_classifier` with one hidden layer.\n",
                "\n",
                "We also create 2  variants of each training sample with stochastic augmentation by setting `n_augmentation_variants=2`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [],
            "source": [
                "# replace the default 1-layer classification head with a 2-layer MLP (2 fully-connected layers)\n",
                "perch2.initialize_custom_classifier(hidden_layer_sizes=[100], classes=classes)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 17,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the training samples 2 times with stochastic augmentation\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "16d71dcccebe4ff38288c88a8999b174",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/2 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the validation samples\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "adebe56ab22f448fa3a9515f3905160e",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/2 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Fitting the classifier\n",
                        "Step 100/1000, Loss: 0.004, Val Loss: 0.364, val AU ROC: 0.965, val MAP: 0.955\n",
                        "Step 200/1000, Loss: 0.001, Val Loss: 0.417, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 300/1000, Loss: 0.001, Val Loss: 0.452, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 400/1000, Loss: 0.000, Val Loss: 0.478, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 500/1000, Loss: 0.000, Val Loss: 0.499, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 600/1000, Loss: 0.000, Val Loss: 0.516, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 700/1000, Loss: 0.000, Val Loss: 0.532, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 800/1000, Loss: 0.000, Val Loss: 0.545, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 900/1000, Loss: 0.000, Val Loss: 0.557, val AU ROC: 0.968, val MAP: 0.960\n",
                        "Step 1000/1000, Loss: 0.000, Val Loss: 0.567, val AU ROC: 0.970, val MAP: 0.965\n",
                        "Loaded best model with validation loss: 0.297 at step 30 of 1000\n",
                        "Training complete\n"
                    ]
                }
            ],
            "source": [
                "# train the classifier in one step: this function first creates embeddings, then fits the classification head\n",
                "perch2.train(\n",
                "    train_df=labels_train.groupby(\"A\").sample(20),\n",
                "    validation_df=labels_val.groupby(\"A\").sample(20),\n",
                "    n_augmentation_variants=2,\n",
                "    embedding_batch_size=32,\n",
                "    embedding_num_workers=num_workers,\n",
                "    steps=1000,\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### Evaluate"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "d848a444fe55434faba40f669c153215",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/4 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/plain": [
                            "0.9637046307884856"
                        ]
                    },
                    "execution_count": 18,
                    "metadata": {},
                    "output_type": "execute_result"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1500x500 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "image/png": {
                            "height": 428,
                            "width": 1209
                        }
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# make predictions by passing the embeddings through the classifier\n",
                "subset = labels_val.sample(64)\n",
                "perch2.classes = classes\n",
                "preds = perch2.predict(subset, batch_size=16, num_workers=num_workers)\n",
                "\n",
                "# Note: if we already have the embeddings, we could have created epredictions much more quickly by running\n",
                "# perch.network(torch.tensor(val_embeddings.float()))\n",
                "\n",
                "# plot histogram of scores for positive and negative clips\n",
                "plt.hist(preds[subset.A == True], bins=20, alpha=0.5, label=\"positives\")\n",
                "plt.hist(preds[subset.A == False], bins=20, alpha=0.5, label=\"negatives\")\n",
                "plt.legend()\n",
                "\n",
                "# calculate the area under the ROC score\n",
                "roc_auc_score(subset.values, preds, average=None)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Variations on training\n",
                "\n",
                "OpenSoundscape also provides tools to generate embeddings for augmented variations of the input samples (`opensoundscape.shallow_classifier.augmented_embed()`), which could improve the classifiers performance and generalizability. See the transfer learning tutorial for further examples of this and other workflows. \n",
                "\n",
                "Here are a few other tools from the `shallow_classifiers` module to check out:\n",
                "\n",
                "- augmented_embed(): generate embeddings for each sample multiple times, with stochastic augmentation on the audio clips\n",
                "\n",
                "- fit_classifier_on_embeddings(): this function wraps together the embedding step with the classifier fitting step into a single operation, with support for generating augmented variations of training samples. It returns the embeddings and labels, in case you want to train additional classifiers on them\n",
                "\n",
                "- MLPClassifier: this class creates a neural network with one or more fully connected layers. This object can be trained by passing it to fit() or fit_classifier_on_embeddings(), or by running the MLPClassifier.fit() method (equivalent to fit(model)). The input size should match the embedding size of the embedding model, and the output size should match the number of classes your model predicts on. "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Clean Up"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 19,
            "metadata": {},
            "outputs": [],
            "source": [
                "try:\n",
                "    Path(\"custom_birdnet_classifier.pth\").unlink()\n",
                "except:\n",
                "    pass"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "opso_dev",
            "language": "python",
            "name": "opso_dev"
        },
        "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.13.5"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}