01-segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b5267f99",
   "metadata": {},
   "source": [
    "# Segmentation\n",
    "\n",
    "This notebooks is adapted from [this page](https://vocalpy.readthedocs.io/en/latest/user/howto/segmentation-ir-metrics.html) of the VocalPy docs. It replicates part of the analysis from [Ghaffari Devos 2023](https://dael.euracoustics.org/confs/fa2023/data/articles/000897.pdf), adapting code from https://github.com/houtan-ghaffari/bird_syllable_segmentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9db33941-ccae-462c-a8de-9a9ab04a5a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/tessa/opt/anaconda3/envs/acabb-env/lib/python3.11/site-packages/dask/dataframe/__init__.py:31: FutureWarning: \n",
      "Dask dataframe query planning is disabled because dask-expr is not installed.\n",
      "\n",
      "You can install it with `pip install dask[dataframe]` or `conda install dask`.\n",
      "This will raise in a future version.\n",
      "\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "import vocalpy as voc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "199b78d0-2e79-44c9-a379-e80e86754e24",
   "metadata": {},
   "source": [
    "We load an example as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3c2252b8-5579-4e92-8a3a-f1ae05387d73",
   "metadata": {},
   "outputs": [],
   "source": [
    "example = voc.example('samba.wav')\n",
    "sound = voc.Sound.read(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45887cc2-308b-40ea-8d9a-39f7ed6f753c",
   "metadata": {},
   "source": [
    "## the `vocalpy.Segments` data type"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ddc365-0bbe-40c6-bcd9-92e4e2995e97",
   "metadata": {},
   "source": [
    "We're going to segment that sound with one of the methods built into the `vocalpy.segment` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f8d1d77c-34ab-47b4-9e2b-06f6a422e165",
   "metadata": {},
   "outputs": [],
   "source": [
    "segments = voc.segment.meansquared(sound)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c70ac7b-e98d-4787-b8b8-41a104051cc3",
   "metadata": {},
   "source": [
    "This gives us back a `vocalpy.Segments` instance, with the starting index and length of a set of line segments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b6d96a95-535a-4e92-9c1b-3454a274fff2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Segments(start_inds=array([  762,...36423, 47977]), lengths=array([ 2775,...10086, 15848]), labels=['', '', '', '', '', '', ...], sound=vocalpy.Sound(data=array([[0.003... 0.        ]]), samplerate=44100, path=/Users/tessa/opt/anaconda3/envs/acabb-env/lib/python3.11/site-packages/vocalpy/examples/samba.wav))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0027cb7-9d97-44ac-be38-cc0a4839f9ab",
   "metadata": {},
   "source": [
    "How many segments are there?The \"raw data\" of segments is given in term of sample indices, because on a computer we are always dealing with digital samples anyways.\n",
    "\n",
    "But as humans it's easier for us to think"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "72ea3b09-56c6-4517-8fe0-3d84d069005e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(segments)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5101d73b-525b-4242-a67b-1b2750d7dcac",
   "metadata": {},
   "source": [
    "Because on a computer we are always dealing with digital samples, the \"raw data\" of segments is given in term of samples and indices: the index of the `start_sample` and the `length` of the segment in samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2c550a10-f49c-44da-a8ea-94f3cfc55723",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  762,  4096, 15570, 20724, 33547, 36423, 47977])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments.start_inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7796d12a-36c2-4ff9-a5c0-a6f9d1dcf090",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2775, 10026,  4462, 10669,  2254, 10086, 15848])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments.lengths"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2a60a65-f028-4d6e-bb06-39cdd29bcdb6",
   "metadata": {},
   "source": [
    "But as humans it's often easier for us to think of segments in terms of seconds. The `Segments` class will convert to seconds for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4f200ecd-26e2-4488-8835-607e659cd31a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.01727891, 0.09287982, 0.35306122, 0.46993197, 0.76070295,\n",
       "       0.82591837, 1.08791383])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments.start_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9b2fb15c-f443-4275-bab3-460a3bba9ef4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.06292517, 0.22734694, 0.10117914, 0.24192744, 0.05111111,\n",
       "       0.22870748, 0.35936508])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments.durations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2950d078-8e6e-4222-9b84-9a1acb2642a5",
   "metadata": {},
   "source": [
    "## the `vocalpy.Segmenter` class\n",
    "\n",
    "Like when we made spectrograms, we can use a `Segmenter` class to capture the function and parameters we use, and to trivially parallelize processing a bunch of files.\n",
    "\n",
    "For this notebook, We will use a subset of data from the [Bengalese Finch Song Repository](https://nickledave.github.io/bfsongrepo/).\n",
    "\n",
    "Note this data is also built into VocalPy as an example, but that it gets downloaded when you call `vocalpy.example('bfsongrepo')` -- so we downloaded it ahead of time, to avoid having a room full of people downloaded MBs of data all at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bb227b29-8cb4-4794-bf04-36580058e615",
   "metadata": {},
   "outputs": [],
   "source": [
    "bfsongrepo_dir = './data/Nicholson-Queen-Sober-2017-bfsongrepo-subset/'\n",
    "wav_paths = voc.paths.from_dir(bfsongrepo_dir, 'wav')\n",
    "csv_paths = voc.paths.from_dir(bfsongrepo_dir, 'csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "eccc745c-219e-4700-858d-05a23eeb3cf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "sounds = [\n",
    "    voc.Sound.read(wav_path)\n",
    "    for wav_path in wav_paths\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "218bb22c-e308-4afe-af4f-654971944fe6",
   "metadata": {},
   "source": [
    "We will use the `voc.segment.meansquared` function, and to be extra explicit we use a data class, `voc.segment.MeanSquaredParams`, to represent the parameters we use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1031738d-c8b5-4dce-8b8c-98688558bc89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[########################################] | 100% Completed | 975.50 ms\n"
     ]
    }
   ],
   "source": [
    "callback = voc.segment.meansquared\n",
    "params = voc.segment.MeanSquaredParams(threshold=1500, min_dur=0.01, min_silent_dur=0.006)\n",
    "segmenter = voc.Segmenter(callback, params)\n",
    "segments_list = segmenter.segment(sounds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cf78ae90-0485-48ba-bfae-9331e323f59b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Segments(start_inds=array([ 12057...3093, 225644]), lengths=array([2268, ..., 2138, 2747]), labels=['', '', '', '', '', '', ...], sound=vocalpy.Sound(data=array([[-0.00...-0.00753784]]), samplerate=32000, path=data/Nicholson-Queen-Sober-2017-bfsongrepo-subset/gy6or6_baseline_220312_0836.3.wav))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments_list[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ec558dd",
   "metadata": {},
   "source": [
    "## Segmentation metrics\n",
    "\n",
    "The goal of our evaluation is to get a measure of how close the segments from an algorithm are to a segmentation created by a human annotator. We will call the annotation created by the human annotator the *ground truth* or *reference* segmentation, and we will call the output of an algorithm the *hypothesis*. \n",
    "\n",
    "The algorithm in question is `vocalpy.segment.meansquared`. This algorithm is used by a Matlab GUI `evsonganaly` originally developed by Evren Tumer in the Brainard Lab, as used in [^3]. The version of the algorithm built into VocalPy is adapted from the Python implementation in the [`evfuncs` package](https://github.com/NickleDave/evfuncs).\n",
    "\n",
    "What we want to understand is the role that different parameters play in the algorithm. \n",
    "To understand the role of these parameters, we will evaluate the output of `vocalpy.segment.meansquared` with and without the clean-up parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "105858e5-4643-4d94-8b6b-28bfa8782198",
   "metadata": {},
   "source": [
    "## Baseline algorithm for segmentation\n",
    "\n",
    "We will also compare with another algorithm that simply sets the threshold to the average of the energy, and doesn't do any post-processing to clean up.\n",
    "\n",
    "Adapted from https://github.com/houtan-ghaffari/bird_syllable_segmentation.  \n",
    "See https://dael.euracoustics.org/confs/fa2023/data/articles/000897.pdf for more detail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d608ffe6-10bc-4127-b741-ba0202b91ef5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "\n",
    "import vocalpy as voc\n",
    "\n",
    "\n",
    "def average_envelope_threshold(sound: voc.Sound, cutoff=500, order=40) -> voc.Segments:\n",
    "    \"\"\"Segment audio by threshold with the average of the envelope.\n",
    "\n",
    "    This function (1) high-pass filters the audio to reduce noise,\n",
    "    (2) extracts the Hilbert envelope, (3) smooths the envelope with a Hann window,\n",
    "    and then (4) thresholds the smoothed envelope to segment, \n",
    "    setting the threshold to average of the envelope.\n",
    "    \n",
    "    Adapted from https://github.com/houtan-ghaffari/bird_syllable_segmentation\n",
    "    See https://dael.euracoustics.org/confs/fa2023/data/articles/000897.pdf for more detail.\n",
    "    \"\"\"\n",
    "    if sound.data.shape[0] > 1:\n",
    "        raise ValueError(\n",
    "            f\"The ``sound`` has {sound.data.shape[0]} channels, but segmentation is not implemented \"\n",
    "            \"for sounds with multiple channels. This is because there can be a different number of segments \"\n",
    "            \"per channel, which cannot be represented as a rectangular array. To segment each channel, \"\n",
    "            \"first split the channels into separate ``vocalpy.Sound`` instances, then pass each to this function.\"\n",
    "            \"For example,\\n\"\n",
    "            \">>> sound_channels = [sound_ for sound_ in sound]  # split with a list comprehension\\n\"\n",
    "            \">>> channel_segments = [vocalpy.segment.meansquared(sound_) for sound_ in sound_channels]\\n\"\n",
    "        )\n",
    "\n",
    "    x = sound.data.squeeze(axis=0)\n",
    "\n",
    "    sos = scipy.signal.butter(\n",
    "        order, cutoff, btype=\"highpass\", analog=False, output=\"sos\", fs=sound.samplerate\n",
    "    )\n",
    "    x = scipy.signal.sosfiltfilt(sos, x)\n",
    "    x = np.abs(scipy.signal.hilbert(x))\n",
    "    win = scipy.signal.windows.hann(512)\n",
    "    x = scipy.signal.convolve(x, win, mode='same') / sum(win)\n",
    "    threshold = np.mean(x)\n",
    "    above_threshold = x > threshold\n",
    "\n",
    "    # convolving with h causes:\n",
    "    # +1 whenever above_th changes from 0 to 1\n",
    "    # and -1 whenever above_th changes from 1 to 0\n",
    "    h = np.array([1, -1])\n",
    "    above_convolved = np.convolve(h, above_threshold)\n",
    "    onsets_sample = np.where(above_convolved > 0)[0]\n",
    "    offsets_sample = np.where(above_convolved < 0)[0]\n",
    "    lengths = offsets_sample - onsets_sample\n",
    "\n",
    "    return voc.Segments(        \n",
    "        start_inds=onsets_sample,\n",
    "        lengths=lengths,\n",
    "        sound=sound\n",
    "    )    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a02579",
   "metadata": {},
   "source": [
    "### Information retrieval metrics\n",
    "\n",
    "The metrics we will use to evaluate segmentation are adapted from the field of [information retrieval](https://en.wikipedia.org/wiki/Information_retrieval). Broadly speaking, this field builds systems to retrieve information, e.g. a program that lets a user query a database of documents (think Google Search). Methods for evaluating these systems have been borrowed by related fields, and by machine learning more broadly. For example, one can also conceive of querying a dataset of audio, as is done in [music information retrieval](https://musicinformationretrieval.com/), and information retrieval metrics have been adapted to evaluate the segentation of audio. See for example the segmentation metrics in the [`mir_eval`](https://craffel.github.io/mir_eval/#module-mir_eval.segment) package."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa577fd",
   "metadata": {},
   "source": [
    "### Segment audio\n",
    "\n",
    "To set ourselves up to analyze the results below, we will make a Python dictionary that maps a string `'name'` (for the algorithm we are testing) to the `list` of `vocalpy.Segments` returned by the algorithm. Since we test the same algorithm twice with different parameters, we will think of this name as a \"condition\" (the three conditions we outlined above)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4ed33cca-7f53-463a-b5f8-632faade0920",
   "metadata": {},
   "outputs": [],
   "source": [
    "algo_segments_map = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4356b0ba-41c1-4f66-a306-63fbfd287e0f",
   "metadata": {},
   "source": [
    "To actually get the results, we will write a loop.\n",
    "Inside the loop, we will use the `vocalpy.Segmenter` class.  \n",
    "This class takes has two parameters: a `callback` function, and the `params` (parameters) we will pass to that function.\n",
    "Each time through the loop, we will make an instance of the `Segmenter` class by passing in a specific `callback` and set of `params` as the two arguments. Then when we call the `segment` method on that instance, the class will call the `callback` function.\n",
    "So, at the top of the loop, we define a tuple of 3-element tuples that we iterate through. Each 3-element tuple has the condition `name`, the `callback` and the `params` we will use with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c62a24fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmenting with algorithm/condition: 'meansquared'\n",
      "[########################################] | 100% Completed | 1.39 ss\n",
      "Segmenting with algorithm/condition: 'meansquared-no-cleanup'\n",
      "[########################################] | 100% Completed | 1.17 sms\n",
      "Segmenting with algorithm/condition: 'average_envelope_threshold'\n",
      "[########################################] | 100% Completed | 317.89 ms\n"
     ]
    }
   ],
   "source": [
    "for name, callback, params in (\n",
    "    ('meansquared', voc.segment.meansquared, voc.segment.MeanSquaredParams(threshold=1500, min_dur=0.01, min_silent_dur=0.006)),\n",
    "    # here we set the parameters for minimum durations to zero, meaning \"don't filter\"\n",
    "    ('meansquared-no-cleanup', voc.segment.meansquared, voc.segment.MeanSquaredParams(threshold=1500, min_dur=0., min_silent_dur=0.)),\n",
    "    # our baseline. We set the params to None. We write it here so we have a value for \"params\" when we loop through these\n",
    "    # even though the default is None\n",
    "    ('average_envelope_threshold', average_envelope_threshold, None)\n",
    "):\n",
    "    print(f\"Segmenting with algorithm/condition: '{name}'\")\n",
    "    segmenter = voc.Segmenter(callback, params)\n",
    "    algo_segments_map[name] = segmenter.segment(sounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b034b714",
   "metadata": {},
   "source": [
    "### Get ground truth data\n",
    "\n",
    "Now we need our reference segmentation to compare to.\n",
    "\n",
    "We will need list of `vocalpy.Segments` for this too, but here we make them using `vocalpy.Annotation` that we load from the example datasets. These annotations contain the ground truth segmentation that we want to compare with the results from the algorithms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c6b2ed1f-0106-4fa9-8e2b-b879f83bed71",
   "metadata": {},
   "outputs": [],
   "source": [
    "annots = [\n",
    "    voc.Annotation.read(csv_path, format='simple-seq')\n",
    "    for csv_path in csv_paths\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6fe002da",
   "metadata": {},
   "outputs": [],
   "source": [
    "ref_segments_list = []\n",
    "for annot, sound in zip(annots, sounds):\n",
    "    start_inds = (annot.data.seq.onsets_s * sound.samplerate).astype(int)\n",
    "    stop_inds = (annot.data.seq.offsets_s * sound.samplerate).astype(int)\n",
    "    lengths = stop_inds - start_inds\n",
    "    ref_segments_list.append(\n",
    "        voc.Segments(\n",
    "            start_inds,\n",
    "            lengths,\n",
    "            sound=sound,\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b6b70de",
   "metadata": {},
   "source": [
    "### Compute metrics\n",
    "\n",
    "Finally we use the functions in the {py:module}`vocalpy.metrics.segmentation.ir` module to compute metrics that we use to compare the segmentation algorithms.\n",
    "\n",
    "The functions in this module expect two arguments: a `reference` segmentation, and a `hypothesis`. In other words, the ground truth and the output of some algorithm that we want to compare with that ground truth.\n",
    "\n",
    "Notice that we use a `tolerance` of 10 milliseconds. This is a standard value used in previous work--you may find it instructive to vary this value and examine the results.\n",
    "\n",
    "We will make a {py:class}`pandas.DataFrame` with the results, that we will then plot with {py:module}`seaborn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "433d75fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "results_records = []  # will become a DataFrame\n",
    "\n",
    "\n",
    "TOLERANCE = 0.01  # milliseconds\n",
    "\n",
    "\n",
    "for name, hypothesis_segments_list in algo_segments_map.items():\n",
    "    for reference, hypothesis in zip(ref_segments_list, hypothesis_segments_list):\n",
    "        prec, _, _ = voc.metrics.segmentation.ir.precision(\n",
    "            reference=reference.all_times,\n",
    "            hypothesis=hypothesis.all_times,\n",
    "            tolerance=0.01  # 10 milliseconds\n",
    "        )\n",
    "        rec, _, _ = voc.metrics.segmentation.ir.recall(\n",
    "            reference=reference.all_times,\n",
    "            hypothesis=hypothesis.all_times,\n",
    "            tolerance=0.01  # 10 milliseconds\n",
    "        )\n",
    "        fscore, _, _ = voc.metrics.segmentation.ir.fscore(\n",
    "            reference=reference.all_times,\n",
    "            hypothesis=hypothesis.all_times,\n",
    "            tolerance=TOLERANCE\n",
    "        )\n",
    "        for metric_name, metric_val in zip(\n",
    "            ('precision', 'recall', 'fscore'),\n",
    "            (prec, rec, fscore)\n",
    "        ):\n",
    "            results_records.append(\n",
    "                {\n",
    "                    'condition': name,\n",
    "                    'metric': metric_name,\n",
    "                    'value': metric_val,\n",
    "                }\n",
    "            )\n",
    "\n",
    "results_df = pd.DataFrame.from_records(results_records)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eeefd97",
   "metadata": {},
   "source": [
    "We inspect the dataframe to check that it looks like what we expect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f5814c31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>condition</th>\n",
       "      <th>metric</th>\n",
       "      <th>value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>meansquared</td>\n",
       "      <td>precision</td>\n",
       "      <td>0.954545</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>meansquared</td>\n",
       "      <td>recall</td>\n",
       "      <td>0.972222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>meansquared</td>\n",
       "      <td>fscore</td>\n",
       "      <td>0.963303</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>meansquared</td>\n",
       "      <td>precision</td>\n",
       "      <td>0.868056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>meansquared</td>\n",
       "      <td>recall</td>\n",
       "      <td>0.961538</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     condition     metric     value\n",
       "0  meansquared  precision  0.954545\n",
       "1  meansquared     recall  0.972222\n",
       "2  meansquared     fscore  0.963303\n",
       "3  meansquared  precision  0.868056\n",
       "4  meansquared     recall  0.961538"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0abe8481",
   "metadata": {},
   "source": [
    "Note this is in \"long\" form where we have a \"variable\" column -- in this case, the different metrics -- and the value that each \"variable\" takes on.\n",
    "\n",
    "We could alternatively have the `DataFrame` in wide form, with columns for `'precision'`, `'recall'`, and `'fscore`, but as we'll see, the long form makes it easier to plot below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a44688b",
   "metadata": {},
   "source": [
    "### Visualize results\n",
    "\n",
    "Now let's do some final clean-up of the dataframe, for plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3d407133",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['value'] = results_df['value'] * 100.\n",
    "\n",
    "results_df['metric'] = results_df['metric'].map(\n",
    "    {\n",
    "        'fscore': '$F$-score (%)',\n",
    "        'precision': 'Precision (%)',\n",
    "        'recall': 'Recall (%)',\n",
    "    },\n",
    "    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e1477abc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1973.25x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "sns.set_context('talk', font_scale=1.25)\n",
    "sns.set_style('darkgrid')\n",
    "\n",
    "\n",
    "g = sns.catplot(\n",
    "    results_df,\n",
    "    y='value',\n",
    "    hue='condition',\n",
    "    col='metric',\n",
    "    kind='bar',\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "494d37f4",
   "metadata": {},
   "source": [
    "We can see that the `'meansquared'` algorithm *with* the clean-up steps has the highest precision and recall. Perhaps surprisingly, the `'meansquared'` algorithm *without* clean-up has a *lower* precision than the `average_envelope_threshold`, and even more surprisingly, it has the highest recall of all. We can understand this as follows: the `'meansquared'` algorithm finds \"more\" segments than the `'average_envelope_threshold'` algorithm--giving it a higher recall--but that also means it returns more false positives. More generally, a result like this would suggest that the clean-up steps have a bigger impact on performance than the methods used to compute the energy and the exact threshold used. Keep in mind that we've shown here is just a demo. To really draw this conclusion we'd need to do an extensive analysis across datasets, and be very clear about our intended use cases for the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c72c0641-cd40-49dd-b007-acfc9ca82993",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96b52383-239a-4f65-9ffd-8486555dc7b6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34b6b4e9-453c-450e-8f1a-b262c2af5b2a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}