{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Train classifiers on BirdNET or Perch embeddings\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_cnn.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": null, "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.12.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_55607/4234765199.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, quick_fit, 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": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--2025-02-28 12:50:59-- https://datadryad.org/stash/downloads/file_stream/2722802\n", "Resolving datadryad.org (datadryad.org)... 44.231.126.195, 35.161.56.100, 44.236.210.21, ...\n", "Connecting to datadryad.org (datadryad.org)|44.231.126.195|:443... connected.\n", "HTTP request sent, awaiting response... 403 Forbidden\n", "2025-02-28 12:51:00 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": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/SML161/miniconda3/envs/bmz_dev/lib/python3.10/site-packages/opensoundscape/annotations.py:302: 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": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "A 585\n", "E 154\n", "D 61\n", "B 22\n", "C 91\n", "X 120\n", "dtype: int64" ] }, "execution_count": 5, "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": 6, "metadata": {}, "outputs": [], "source": [ "labels_train, labels_val = sklearn.model_selection.train_test_split(labels[[\"A\"]])" ] }, { "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.quick_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": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/SML161/bioacoustics-model-zoo/bioacoustics_model_zoo/bmz_birdset/bmz_birdset.py:31: UserWarning: \n", "The version_base parameter is not specified.\n", "Please specify a compatability version level, or None.\n", "Will assume defaults for version 1.1\n", " hydra.initialize(config_path=\"configs\") # relative to current working dir\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "File BirdNET_GLOBAL_6K_V2.4_Labels_af.txt already exists; skipping download.\n", "downloading model from URL...\n", "File BirdNET_GLOBAL_6K_V2.4_Model_FP16.tflite already exists; skipping download.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/SML161/miniconda3/envs/bmz_dev/lib/python3.10/site-packages/opensoundscape/ml/cnn.py:628: UserWarning: \n", " This architecture is not listed in opensoundscape.ml.cnn_architectures.ARCH_DICT.\n", " It will not be available for loading after saving the model with .save() (unless using pickle=True). \n", " To make it re-loadable, define a function that generates the architecture from arguments: (n_classes, n_channels) \n", " then use opensoundscape.ml.cnn_architectures.register_architecture() to register the generating function.\n", "\n", " The function can also set the returned object's .constructor_name to the registered string key in ARCH_DICT\n", " to avoid this warning and ensure it is reloaded correctly by opensoundscape.ml.load_model().\n", "\n", " See opensoundscape.ml.cnn_architectures module for examples of constructor functions\n", " \n", " warnings.warn(\n", "/Users/SML161/miniconda3/envs/bmz_dev/lib/python3.10/site-packages/opensoundscape/ml/cnn.py:652: UserWarning: Failed to detect expected # input channels of this architecture.Make sure your architecture expects the number of channels equal to `channels` argument 1). Pytorch architectures generally expect 3 channels by default.\n", " warnings.warn(\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": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5eab070a3d1346e1a04d020a5e983dac", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/12 [00:00" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "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": [ "### 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": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Embedding the training samples without augmentation\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5f93df7495a346498b740946ad81d322", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/12 [00:00" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "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. " ] }, { "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": "43a3b29e51474ebe90bbad86565dfca2", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/2 [00:00" ] }, "metadata": { "image/png": { "height": 428, "width": 1209 } }, "output_type": "display_data" } ], "source": [ "# make predictions by passing the embeddings through the classifier\n", "preds = perch.predict(labels_val, batch_size=32, 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[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()\n", "\n", "# calculate the area under the ROC score\n", "roc_auc_score(labels_val.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 quick_fit() or fit_classifier_on_embeddings(), or by running the MLPClassifier.fit() method (equivalent to quick_fit()). 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. " ] } ], "metadata": { "kernelspec": { "display_name": "bmz_dev", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.11" } }, "nbformat": 4, "nbformat_minor": 2 }