01b_melspectrogram_dataset_for_pool.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for d in Path('data/npy/train_resampled/').iterdir():\n",
    "#     for r in d.iterdir():\n",
    "#         x = np.load(r)\n",
    "#         assert x.ndim == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from birdcall.data import *\n",
    "\n",
    "import pandas as pd\n",
    "import librosa\n",
    "import matplotlib.pyplot as plt\n",
    "import soundfile as sf\n",
    "from torch.utils.data import Dataset\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "recs = pd.read_pickle('data/recs.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Going from audio to mel spectrogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below adapts [code](https://github.com/f0k/birdclef2018/blob/master/experiments/audio.py) by Jan Schlüter accompanying this very informative [paper](http://ceur-ws.org/Vol-2125/paper_181.pdf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "audio, _ = sf.read('data/train_resampled/norpar/XC173778.wav')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57.456"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "audio.shape[0] / SAMPLE_RATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "audio = audio[:5*SAMPLE_RATE] # grabbing only the first five seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "\n",
    "from pyfftw.builders import rfft as rfft_builder\n",
    "from pyfftw import empty_aligned\n",
    "from pathlib import Path\n",
    "\n",
    "mel_bands=80\n",
    "mel_min=27.5\n",
    "mel_max=10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "\n",
    "def spectrogram(samples, sample_rate, frame_len, fps, batch=48, dtype=None,\n",
    "                bins=None, plans=None):\n",
    "    \"\"\"\n",
    "    Computes a magnitude spectrogram for a given vector of samples at a given\n",
    "    sample rate (in Hz), frame length (in samples) and frame rate (in Hz).\n",
    "    Allows to transform multiple frames at once for improved performance (with\n",
    "    a default value of 48, more is not always better). Returns a numpy array.\n",
    "    Allows to return a limited number of bins only, with improved performance\n",
    "    over discarding them afterwards. Optionally accepts a set of precomputed\n",
    "    plans created with spectrogram_plans(), required when multi-threading.\n",
    "    \"\"\"\n",
    "    if dtype is None:\n",
    "        dtype = samples.dtype\n",
    "    if bins is None:\n",
    "        bins = frame_len // 2 + 1\n",
    "    if len(samples) < frame_len:\n",
    "        return np.empty((0, bins), dtype=dtype)\n",
    "    if plans is None:\n",
    "        plans = spectrogram_plans(frame_len, batch, dtype)\n",
    "    rfft1, rfft, win = plans\n",
    "    hopsize = int(sample_rate // fps)\n",
    "    num_frames = (len(samples) - frame_len) // hopsize + 1\n",
    "    nabs = np.abs\n",
    "    naa = np.asanyarray\n",
    "    if batch > 1 and num_frames >= batch and samples.flags.c_contiguous:\n",
    "        frames = np.lib.stride_tricks.as_strided(\n",
    "                samples, shape=(num_frames, frame_len),\n",
    "                strides=(samples.strides[0] * hopsize, samples.strides[0]))\n",
    "        spect = [nabs(rfft(naa(frames[pos:pos + batch:], dtype) * win)[:, :bins])\n",
    "                 for pos in range(0, num_frames - batch + 1, batch)]\n",
    "        samples = samples[(num_frames // batch * batch) * hopsize::]\n",
    "        num_frames = num_frames % batch\n",
    "    else:\n",
    "        spect = []\n",
    "    if num_frames:\n",
    "        spect.append(np.vstack(\n",
    "                [nabs(rfft1(naa(samples[pos:pos + frame_len:],\n",
    "                                dtype) * win)[:bins:])\n",
    "                 for pos in range(0, len(samples) - frame_len + 1, hopsize)]))\n",
    "    return np.vstack(spect) if len(spect) > 1 else spect[0]\n",
    "\n",
    "\n",
    "def create_mel_filterbank(sample_rate, frame_len, num_bands, min_freq,\n",
    "                          max_freq):\n",
    "    \"\"\"\n",
    "    Creates a mel filterbank of `num_bands` triangular filters, with the first\n",
    "    filter starting at `min_freq` and the last one stopping at `max_freq`.\n",
    "    Returns the filterbank as a matrix suitable for a dot product against\n",
    "    magnitude spectra created from samples at a sample rate of `sample_rate`\n",
    "    with a window length of `frame_len` samples.\n",
    "    \"\"\"\n",
    "    # prepare output matrix\n",
    "    input_bins = (frame_len // 2) + 1\n",
    "    filterbank = np.zeros((input_bins, num_bands))\n",
    "\n",
    "    # mel-spaced peak frequencies\n",
    "    min_mel = 1127 * np.log1p(min_freq / 700.0)\n",
    "    max_mel = 1127 * np.log1p(max_freq / 700.0)\n",
    "    spacing = (max_mel - min_mel) / (num_bands + 1)\n",
    "    peaks_mel = min_mel + np.arange(num_bands + 2) * spacing\n",
    "    peaks_hz = 700 * (np.exp(peaks_mel / 1127) - 1)\n",
    "    fft_freqs = np.linspace(0, sample_rate / 2., input_bins)\n",
    "    peaks_bin = np.searchsorted(fft_freqs, peaks_hz)\n",
    "\n",
    "    # fill output matrix with triangular filters\n",
    "    for b, filt in enumerate(filterbank.T):\n",
    "        # The triangle starts at the previous filter's peak (peaks_freq[b]),\n",
    "        # has its maximum at peaks_freq[b+1] and ends at peaks_freq[b+2].\n",
    "        left_hz, top_hz, right_hz = peaks_hz[b:b + 3]  # b, b+1, b+2\n",
    "        left_bin, top_bin, right_bin = peaks_bin[b:b + 3]\n",
    "        # Create triangular filter compatible to yaafe\n",
    "        filt[left_bin:top_bin] = ((fft_freqs[left_bin:top_bin] - left_hz) /\n",
    "                                  (top_bin - left_bin))\n",
    "        filt[top_bin:right_bin] = ((right_hz - fft_freqs[top_bin:right_bin]) /\n",
    "                                   (right_bin - top_bin))\n",
    "        filt[left_bin:right_bin] /= filt[left_bin:right_bin].sum()\n",
    "\n",
    "    return filterbank\n",
    "\n",
    "def spectrogram_plans(frame_len, batch=48, dtype=np.float32):\n",
    "    \"\"\"\n",
    "    Precompute plans for spectrogram(), for a given frame length, batch size\n",
    "    and dtype. Returns two plans (single spectrum and batch), and a window.\n",
    "    \"\"\"\n",
    "    input_array = empty_aligned((batch, frame_len), dtype=dtype)\n",
    "    win = np.hanning(frame_len).astype(dtype)\n",
    "    return (rfft_builder(input_array[0]), rfft_builder(input_array), win)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "spec = spectrogram(audio, SAMPLE_RATE, 256, 128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7ff6cd7b23d0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(spec.T, origin='lower')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filterbank = create_mel_filterbank(SAMPLE_RATE, 256, mel_bands, mel_min, mel_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7ff6cd69be50>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow((spec @ filterbank).T, origin='lower', aspect='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pulling it all together into a datset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "\n",
    "def audio_to_melspec(audio):\n",
    "    spec = spectrogram(audio, SAMPLE_RATE, 256, 128)\n",
    "    filterbank = create_mel_filterbank(SAMPLE_RATE, 256, mel_bands, mel_min, mel_max)\n",
    "    return (spec @ filterbank).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.debugger import set_trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "\n",
    "class MelspecPoolDataset(Dataset):\n",
    "    def __init__(self, recs, classes, len_mult=20, specs_per_example=30, normalize=True):\n",
    "        self.recs = recs\n",
    "        self.vocab = classes\n",
    "        self.specs_per_example = specs_per_example\n",
    "        self.len_mult = len_mult\n",
    "        self.do_norm = normalize\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "        cls_idx = idx % len(self.vocab)\n",
    "        recs = self.recs[classes[cls_idx]]\n",
    "        path, duration = recs[np.random.randint(0, len(recs))]\n",
    "        example = self.sample_specs(path, duration, self.specs_per_example)\n",
    "        if self.do_norm: example = self.normalize(example)\n",
    "        imgs = example.reshape(-1, 3, 80, 212)\n",
    "        return imgs.astype(np.float32), self.one_hot_encode(cls_idx)\n",
    "    \n",
    "    def sample_specs(self, path, duration, count):\n",
    "        if path.name.split('.')[1] == 'wav':\n",
    "            x, _ = sf.read(path)\n",
    "\n",
    "            if x.shape[0] < 1.66*SAMPLE_RATE:\n",
    "                x =  np.tile(x, 5) # the shortest rec in the train set is 0.39 sec\n",
    "\n",
    "            xs = []\n",
    "            for _ in range(count):\n",
    "                start_frame = int(np.random.rand() * (x.shape[0] - 1.66 * SAMPLE_RATE))\n",
    "                xs.append(x[start_frame:start_frame+int(1.66*SAMPLE_RATE)])\n",
    "\n",
    "            specs = []\n",
    "            for x in xs:\n",
    "                specs.append(audio_to_melspec(x))\n",
    "        else: # .npy\n",
    "            frames_per_spec = 212\n",
    "            x = np.load(path)\n",
    "            if x.shape[1] < frames_per_spec:\n",
    "                x = np.tile(x, frames_per_spec // x.shape[1] + 1)\n",
    "                \n",
    "            specs = []\n",
    "            for _ in range(count):\n",
    "                start_frame = int(np.random.rand() * (x.shape[1] - frames_per_spec))\n",
    "                specs.append(x[:, start_frame:start_frame+frames_per_spec])\n",
    "                \n",
    "        return np.stack(specs)\n",
    "    \n",
    "    def normalize(self, example):\n",
    "        return (example - 0.12934518) / 0.5612393\n",
    "    \n",
    "    def show(self, idx):\n",
    "        x = self[idx][0][0]\n",
    "        return plt.imshow(x.transpose(1,2,0)[:, :, 0])\n",
    "        \n",
    "    def one_hot_encode(self, y):\n",
    "        one_hot = np.zeros((len(self.vocab)))\n",
    "        one_hot[y] = 1\n",
    "        return one_hot\n",
    "    def __len__(self):\n",
    "        return self.len_mult * len(self.vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = pd.read_pickle('data/classes.pkl')\n",
    "train_ds = MelspecPoolDataset(pd.read_pickle('data/train_set.pkl'), classes)\n",
    "valid_ds = MelspecPoolDataset(pd.read_pickle('data/val_set.pkl'), classes, len_mult=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = pd.read_pickle('data/classes.pkl')\n",
    "train_ds = MelspecPoolDataset(pd.read_pickle('data/class2train_items.pkl'), classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fbe07ea1d10>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_ds.show(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 15min 22s, sys: 49.4 s, total: 16min 11s\n",
      "Wall time: 2min 4s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "x = []\n",
    "for i in range(264*3):\n",
    "    x.append(train_ds[i][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.12934518, 0.5612393)"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.stack(x).mean(), np.stack(x).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "\n",
    "class MelspecPoolWithShiftedDataset(Dataset):\n",
    "    def __init__(self, recs, classes, len_mult=60, specs_per_example=30, shifted_ratio=0.2):\n",
    "        self.recs = recs\n",
    "        self.vocab = classes\n",
    "        self.specs_per_example = specs_per_example\n",
    "        self.len_mult = len_mult\n",
    "        self.shifted_ratio = 0.2\n",
    "        self.shifted_recs = self.get_shifted_recs()\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "        cls_idx = idx % len(self.vocab)\n",
    "        if np.random.rand() > self.shifted_ratio:\n",
    "            shifted = 0.\n",
    "            recs = self.recs[classes[cls_idx]]\n",
    "        else:\n",
    "            shifted = 1.\n",
    "            recs = self.shifted_recs\n",
    "        path, duration = recs[np.random.randint(0, len(recs))]\n",
    "        example = self.sample_specs(path, duration, self.specs_per_example)\n",
    "        imgs = example.reshape(-1, 3, 80, 212)\n",
    "        return imgs.astype(np.float32), self.one_hot_encode(cls_idx), shifted\n",
    "    \n",
    "    def sample_specs(self, path, duration, count):\n",
    "        x, _ = sf.read(path)\n",
    "\n",
    "        if x.shape[0] < 1.66*SAMPLE_RATE:\n",
    "            x =  np.tile(x, 5) # the shortest rec in the train set is 0.39 sec\n",
    "\n",
    "        xs = []\n",
    "        for _ in range(count):\n",
    "            start_frame = int(np.random.rand() * (x.shape[0] - 1.66 * SAMPLE_RATE))\n",
    "            xs.append(x[start_frame:start_frame+int(1.66*SAMPLE_RATE)])\n",
    "\n",
    "        specs = []\n",
    "        for x in xs:\n",
    "            specs.append(audio_to_melspec(x))\n",
    "        return np.stack(specs)\n",
    "    \n",
    "    def get_shifted_recs(self):\n",
    "        recs = []\n",
    "        for path in Path('data/shifted').iterdir():\n",
    "            recs.append((path, sf.info(path).duration))\n",
    "        return recs\n",
    "    \n",
    "    def show(self, idx):\n",
    "        x = self[idx][0][0]\n",
    "        return plt.imshow(x.transpose(1,2,0)[:, :, 0])\n",
    "        \n",
    "    def one_hot_encode(self, y):\n",
    "        one_hot = np.zeros((len(self.vocab)))\n",
    "        one_hot[y] = 1\n",
    "        return one_hot\n",
    "    def __len__(self):\n",
    "        return self.len_mult * len(self.vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "def from_timestamp_to_offset(ts):\n",
    "    '00:01:45-00:01:50'\n",
    "    start = ts.split('-')[0]\n",
    "    _, mins, sec = start.split(':')\n",
    "    return int(mins) * 60 + int(sec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "soundscapes = [\n",
    "    'data/BirdCLEF2020_val/gt/SSW49_20170520.csv',\n",
    "    'data/BirdCLEF2020_val/gt/SSW50_20170819.csv',\n",
    "    'data/BirdCLEF2020_val/gt/SSW51_20170819.csv',\n",
    "    'data/BirdCLEF2020_val/gt/SSW52_20170429.csv',\n",
    "    'data/BirdCLEF2020_val/gt/SSW53_20170513.csv',\n",
    "    'data/BirdCLEF2020_val/gt/SSW54_20170610.csv'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "soundscape_items = []\n",
    "\n",
    "for soundscape in soundscapes:\n",
    "    rec_fn = f'{Path(soundscape).stem}.wav'\n",
    "    df = pd.read_csv(soundscape, header=None)\n",
    "    offsets_with_labels = defaultdict(list)\n",
    "    for _, (ts, ebird_code) in df.iterrows():\n",
    "        assert ebird_code in classes\n",
    "        offset = from_timestamp_to_offset(ts)\n",
    "        offsets_with_labels[offset].append(ebird_code)\n",
    "    for offset in offsets_with_labels.keys():\n",
    "        soundscape_items.append((offsets_with_labels[offset], Path(f'data/BirdCLEF2020_val/audio/{rec_fn}'), offset)) \n",
    "\n",
    "    i = 0\n",
    "    duration = sf.info(Path(f'data/BirdCLEF2020_val/audio/{rec_fn}')).duration\n",
    "    while i * 5 < duration - 5:\n",
    "        if i * 5 not in offsets_with_labels.keys():\n",
    "            soundscape_items.append(([], Path(f'data/BirdCLEF2020_val/audio/{rec_fn}'), i*5))\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.to_pickle(soundscape_items, 'data/soundscape_items.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export data\n",
    "class SoundscapeMelspecPoolDataset(Dataset):\n",
    "    def __init__(self, items, classes):\n",
    "        self.items = items\n",
    "        self.vocab = classes\n",
    "        \n",
    "    def __getitem__(self, idx):\n",
    "        classes, path, offset = self.items[idx]\n",
    "        cls_idxs = [self.vocab.index(cls) for cls in classes]\n",
    "        example = self.get_specs(path, offset)\n",
    "        imgs = example.reshape(-1, 3, 80, 212)\n",
    "        return imgs.astype(np.float32), self.one_hot_encode(cls_idxs)\n",
    "    \n",
    "    def get_specs(self, path, offset):\n",
    "        if path.name.split('.')[1] == 'wav':\n",
    "            x, _ = sf.read(path, frames=5*SAMPLE_RATE, start=offset*SAMPLE_RATE)\n",
    "\n",
    "            xs = []\n",
    "            for i in range(3):\n",
    "                start_frame = int(i * 1.66 * SAMPLE_RATE)\n",
    "                xs.append(x[start_frame:start_frame+int(1.66*SAMPLE_RATE)])\n",
    "\n",
    "            specs = []\n",
    "            for x in xs:\n",
    "                specs.append(audio_to_melspec(x))\n",
    "        else: # .npy\n",
    "            frames_per_spec = 212\n",
    "            x = np.load(path)\n",
    "                \n",
    "            specs = []\n",
    "            for i in range(3):\n",
    "                start_frame = offset+i*frames_per_spec\n",
    "                specs.append(x[:, start_frame:start_frame+frames_per_spec])       \n",
    "                \n",
    "        return np.stack(specs)\n",
    "        \n",
    "    def one_hot_encode(self, ys):\n",
    "        one_hot = np.zeros((len(self.vocab)))\n",
    "        for y in ys: one_hot[y] = 1\n",
    "        return one_hot\n",
    "    def __len__(self):\n",
    "        return len(self.items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "sds = SoundscapeMelspecPoolDataset(pd.read_pickle('data/soundscape_items.pkl'), classes)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}