{
    "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": 2,
            "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.0\" \"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": 3,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/var/folders/d8/265wdp1n0bn_r85dh3pp95fh0000gq/T/ipykernel_97961/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": 4,
            "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": [
                        "--2026-05-02 13:44:29--  https://datadryad.org/stash/downloads/file_stream/2722802\n",
                        "Resolving datadryad.org (datadryad.org)... 44.230.249.8, 52.26.167.239, 44.225.159.71, ...\n",
                        "Connecting to datadryad.org (datadryad.org)|44.230.249.8|:443... connected.\n",
                        "HTTP request sent, awaiting response... 301 Moved Permanently\n",
                        "Location: https://datadryad.org/downloads/file_stream/2722802 [following]\n",
                        "--2026-05-02 13:44:30--  https://datadryad.org/downloads/file_stream/2722802\n",
                        "Reusing existing connection to datadryad.org:443.\n",
                        "HTTP request sent, awaiting response... 403 Forbidden\n",
                        "2026-05-02 13:44:30 ERROR 403: Forbidden.\n",
                        "\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": 6,
            "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": 7,
            "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": 7,
                    "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": null,
            "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": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "downloading model from URL...\n"
                    ]
                }
            ],
            "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": 19,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "/Users/SML161/opensoundscape/opensoundscape/ml/cnn.py:2958: 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": "8a7eb47d0b554ff8bffffcacd000ad92",
                            "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:2958: 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": "85f46446bdfe4ff09aa41d1b32a33347",
                            "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": null,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Step 100/300, Loss: 0.310, Val Loss: 0.292, val AU ROC: 0.941, val MAP: 0.844\n",
                        "Step 200/300, Loss: 0.274, Val Loss: 0.270, val AU ROC: 0.943, val MAP: 0.849\n",
                        "Step 300/300, Loss: 0.222, Val Loss: 0.262, val AU ROC: 0.944, val MAP: 0.850\n",
                        "Loaded best model with validation loss: 0.262 at step 297 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.26155926535526913,\n",
                            " 'auroc': 0.9439022944210589,\n",
                            " 'map': 0.8502054493981454,\n",
                            " 'per_class_auroc': [0.9439022944210589]}"
                        ]
                    },
                    "execution_count": 32,
                    "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": 22,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "ROC AUC Score: 0.942\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": 23,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "<matplotlib.legend.Legend at 0x3401c3230>"
                        ]
                    },
                    "execution_count": 23,
                    "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": 24,
            "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": 25,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "a7065c2f0de24cd493c2e075ea95549f",
                            "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>-2.712375</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>-2.332742</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>-3.837755</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>-3.979539</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>-1.336104</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      -2.712375\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 3.0        6.0      -2.332742\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 9.0        12.0     -3.837755\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 3.0        6.0      -3.979539\n",
                            "rana_sierrae_2022/mp3/sine2022a_MSD-0558_202206... 6.0        9.0      -1.336104"
                        ]
                    },
                    "execution_count": 25,
                    "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": 26,
            "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": 27,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the training samples without augmentation\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "70103605847c45828d62c17d4b537846",
                            "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": "211f2a3b2b76461981053ee113f2bce2",
                            "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.153, Val Loss: 0.375, val AU ROC: 0.915, val MAP: 0.783\n",
                        "Step 200/1000, Loss: 0.070, Val Loss: 0.403, val AU ROC: 0.906, val MAP: 0.762\n",
                        "Step 300/1000, Loss: 0.040, Val Loss: 0.436, val AU ROC: 0.903, val MAP: 0.757\n",
                        "Step 400/1000, Loss: 0.027, Val Loss: 0.465, val AU ROC: 0.902, val MAP: 0.757\n",
                        "Step 500/1000, Loss: 0.019, Val Loss: 0.490, val AU ROC: 0.903, val MAP: 0.757\n",
                        "Step 600/1000, Loss: 0.015, Val Loss: 0.513, val AU ROC: 0.903, val MAP: 0.757\n",
                        "Step 700/1000, Loss: 0.011, Val Loss: 0.532, val AU ROC: 0.899, val MAP: 0.754\n",
                        "Step 800/1000, Loss: 0.009, Val Loss: 0.550, val AU ROC: 0.897, val MAP: 0.753\n",
                        "Step 900/1000, Loss: 0.008, Val Loss: 0.566, val AU ROC: 0.896, val MAP: 0.752\n",
                        "Step 1000/1000, Loss: 0.006, Val Loss: 0.581, val AU ROC: 0.896, val MAP: 0.752\n",
                        "Loaded best model with validation loss: 0.373 at step 90 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": 28,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Step 100/300, Loss: 0.231, Val Loss: 0.241, val AU ROC: 0.945, val MAP: 0.853\n",
                        "Step 200/300, Loss: 0.296, Val Loss: 0.245, val AU ROC: 0.941, val MAP: 0.855\n",
                        "Step 300/300, Loss: 0.187, Val Loss: 0.261, val AU ROC: 0.937, val MAP: 0.850\n",
                        "Loaded best model with validation loss: 0.240 at step 122 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.23972870906194052,\n",
                            " 'auroc': 0.9365862334736469,\n",
                            " 'map': 0.8503450673351637,\n",
                            " 'per_class_auroc': [0.9365862334736469]}"
                        ]
                    },
                    "execution_count": 28,
                    "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",
                "# train the classifier in one step: this function first creates embeddings, then fits the classification head\n",
                "# birdnet.train(\n",
                "#     train_df=labels_train,\n",
                "#     validation_df=labels_val,\n",
                "#     embedding_batch_size=64,\n",
                "#     embedding_num_workers=num_workers,\n",
                "#     steps=1000,\n",
                "# )\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": 29,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "auc roc score: 0.9365862334736469\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "<matplotlib.legend.Legend at 0x3512a0910>"
                        ]
                    },
                    "execution_count": 29,
                    "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": 31,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "fdb3467abf49477bb380a2dab8c82467",
                            "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.099, Val Loss: 0.542, val AU ROC: 0.830, val MAP: 0.610\n",
                        "Step 200/300, Loss: 0.041, Val Loss: 0.614, val AU ROC: 0.841, val MAP: 0.635\n",
                        "Step 300/300, Loss: 0.023, Val Loss: 0.677, val AU ROC: 0.845, val MAP: 0.643\n",
                        "Loaded best model with validation loss: 0.490 at step 39 of 300\n",
                        "Training complete\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "{'loss': 0.4899434844652812,\n",
                            " 'auroc': 0.8452362601529614,\n",
                            " 'map': 0.6427193477485879,\n",
                            " 'per_class_auroc': [0.8452362601529614]}"
                        ]
                    },
                    "execution_count": 31,
                    "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": 8,
            "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": null,
            "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:208: 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": 11,
            "metadata": {},
            "outputs": [],
            "source": [
                "# define classes for your custom classifier\n",
                "perch2.change_classes(classes)\n",
                "\n",
                "# 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": 12,
            "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": "3ae223709f8c4b3987ceeb1531569802",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/2 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
                        "I0000 00:00:1777743917.297719 188380475 service.cc:153] XLA service 0x34407a440 initialized for platform Host (this does not guarantee that XLA will be used). Devices:\n",
                        "I0000 00:00:1777743917.298701 188380475 service.cc:161]   StreamExecutor [0]: Host, Default Version (Driver: 0.0.0; Runtime: 0.0.0; Toolkit: 0.0.0; DNN: 0.0.0)\n",
                        "I0000 00:00:1777743917.448584 188380475 dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
                        "W0000 00:00:1777743917.671554 188383069 cpp_gen_intrinsics.cc:74] Empty bitcode string provided for eigen. Optimizations relying on this IR will be disabled.\n",
                        "I0000 00:00:1777743917.671609 188383069 rsqrt.cc:179] Falling back to 1 / sqrt(x) for f32 false\n",
                        "I0000 00:00:1777743917.939103 188380475 device_compiler.h:208] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Embedding the validation samples\n"
                    ]
                },
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "d74186bac8d1423da482c270bf4e291f",
                            "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.007, Val Loss: 0.364, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 200/1000, Loss: 0.002, Val Loss: 0.437, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 300/1000, Loss: 0.001, Val Loss: 0.481, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 400/1000, Loss: 0.000, Val Loss: 0.512, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 500/1000, Loss: 0.000, Val Loss: 0.536, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 600/1000, Loss: 0.000, Val Loss: 0.556, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 700/1000, Loss: 0.000, Val Loss: 0.573, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 800/1000, Loss: 0.000, Val Loss: 0.588, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 900/1000, Loss: 0.000, Val Loss: 0.601, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Step 1000/1000, Loss: 0.000, Val Loss: 0.613, val AU ROC: 0.980, val MAP: 0.983\n",
                        "Loaded best model with validation loss: 0.260 at step 26 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": 21,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "True"
                        ]
                    },
                    "execution_count": 21,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "perch2.use_custom_classifier"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 50,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "application/vnd.jupyter.widget-view+json": {
                            "model_id": "37624c31a3024637bfb35d966ff62fb3",
                            "version_major": 2,
                            "version_minor": 0
                        },
                        "text/plain": [
                            "  0%|          | 0/4 [00:00<?, ?it/s]"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/plain": [
                            "0.41360544217687073"
                        ]
                    },
                    "execution_count": 50,
                    "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": 1201
                        }
                    },
                    "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",
                "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",
                "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": 51,
            "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
}