{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Audio classification the from-scratch way" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Thanks to the SF Study Group practitioners & participants in the [Deep Learning for Audio fastai forum thread](https://forums.fast.ai/t/deep-learning-with-audio-thread/), especially: [Molly Beavers](https://forums.fast.ai/u/marii/summary), [Simon Grest](https://forums.fast.ai/u/simonjhb/), [Stefano Giomo](https://forums.fast.ai/u/ste), [Thom Mackey](https://forums.fast.ai/u/ThomM), [Zach Caceres](https://forums.fast.ai/u/zachcaceres), [Harry Coultas Blum](https://forums.fast.ai/u/baz), & [Robert Bracco](https://forums.fast.ai/u/madeupmasters)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We're going to demonstrate the technique of classifying audio samples by first converting the audio into spectrograms, then treating the spectrograms as images. Once we've converted the spectrograms to images, the workflow is just the same as using imagenette or any other image classification task.\n", "\n", "What do we need to do?\n", "* Download the data\n", "* Load the data \n", "* Transform the data into spectrograms\n", "* Load the audio data into a databunch such that we can use our previously-defined `learner` object\n", "\n", "Still to come - 1D convolutional models, RNNs with audio… and more, with your contribution :)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setup & imports" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We rely heavily on [torchaudio](https://github.com/pytorch/audio) - which you'll have to compile to install." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "from exp.nb_12a import *\n", "import torchaudio\n", "from torchaudio import transforms" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "AUDIO_EXTS = {str.lower(k) for k,v in mimetypes.types_map.items() if v.startswith('audio/')}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Download" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This should be one line; it's only so complicated because the target .tgz file doesn't extract itself to its own directory." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS')" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dsid = \"ST-AEDS-20180100_1-OS\"\n", "data_url = f'http://www.openslr.org/resources/45/{dsid}' # actual URL has .tgz extension but untar_data doesn't like that\n", "path = Path.home() / Path(f\".fastai/data/{dsid}/\")\n", "datasets.untar_data(data_url, dest=path)\n", "path" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading into an AudioList" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Getting a file list the `08_data_block` way." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The \"manual\" way using `get_files`…" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 3842 audio files\n" ] }, { "data": { "text/plain": [ "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00093.wav'),\n", " PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00068.wav'),\n", " PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0002_us_f0002_00192.wav'),\n", " PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00356.wav'),\n", " PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00355.wav')]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "audios = get_files(path, extensions=AUDIO_EXTS)\n", "print(f\"Found {len(audios)} audio files\")\n", "audios[:5]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "…But that's not very exciting. Let's make an `AudioList`, so we can use transforms, and define how to `get` an Audio." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### AudioList" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class AudioList(ItemList):\n", " @classmethod\n", " def from_files(cls, path, extensions=None, recurse=True, include=None, **kwargs):\n", " if extensions is None: extensions = AUDIO_EXTS\n", " return cls(get_files(path, extensions, recurse=recurse, include=include), path, **kwargs)\n", " \n", " def get(self, fn): \n", " sig, sr = torchaudio.load(fn)\n", " assert sig.size(0) == 1, \"Non-mono audio detected, mono only supported for now.\"\n", " return (sig, sr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "AudioList (3842 items)\n", "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00093.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00068.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0002_us_f0002_00192.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00356.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00355.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00134.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00311.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00019.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00005.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00250.wav')...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "al = AudioList.from_files(path); al" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks like this is full of file paths, but that's just the `repr` talking. Actually accessing an item from the list calls the `get` method and returns a `(Tensor, Int)` tuple representing the signal & sample rate." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([[ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -6.1035e-05,\n", " 0.0000e+00, -3.3569e-04]]), 16000)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "al[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Splitting into train/validation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our data is all in one folder, there's no specific validation set, so let's just split it at random." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sd = SplitData.split_by_func(al, partial(random_splitter, p_valid=0.2))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SplitData\n", "Train: AudioList (3042 items)\n", "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00093.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0002_us_f0002_00192.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00355.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00134.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00311.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00019.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00005.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00250.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00318.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0003_us_f0003_00390.wav')...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS\n", "Valid: AudioList (800 items)\n", "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00068.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00356.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00113.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00327.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00205.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0005_us_f0005_00096.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00267.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00064.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00188.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00015.wav')...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Labeling" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our labels are encoded in our filenames. For example, `m0003_us_m0003_00032.wav` has the label `m0003`. Let's make a regex labeler, then use it." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def re_labeler(fn, pat): return re.findall(pat, str(fn))[0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "label_pat = r'/([mf]\\d+)_'\n", "speaker_labeler = partial(re_labeler, pat=label_pat)\n", "ll = label_by_func(sd, speaker_labeler, proc_y=CategoryProcessor())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SplitData\n", "Train: LabeledData\n", "x: AudioList (3042 items)\n", "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00093.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0002_us_f0002_00192.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00355.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00134.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00311.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0002_us_m0002_00019.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00005.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00250.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00318.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0003_us_f0003_00390.wav')...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS\n", "y: ItemList (3042 items)\n", "[0, 1, 2, 3, 2, 0, 4, 4, 3, 5...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS\n", "\n", "Valid: LabeledData\n", "x: AudioList (800 items)\n", "[PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00068.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00356.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00113.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0003_us_m0003_00327.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0004_us_f0004_00205.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0005_us_f0005_00096.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00267.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0005_us_m0005_00064.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/m0001_us_m0001_00188.wav'), PosixPath('/home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS/f0001_us_f0001_00015.wav')...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS\n", "y: ItemList (800 items)\n", "[9, 8, 8, 4, 3, 7, 2, 2, 9, 8...]\n", "Path: /home/jupyter/.fastai/data/ST-AEDS-20180100_1-OS\n" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ll" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Transforms: audio clipping & conversion to spectrograms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The pytorch dataloader needs to be all tensors to be the same size, but our input audio files are of different sizes, so we need to trim them. Also, recall that we're not going to send the model the audio signal directly; we're going to convert it to spectrograms first. We can treat these steps as transforms. We can also apply data augmentation to both the signal and the spectrograms. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Small helpers to show some audio & compare transformed versions." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "from IPython.display import Audio\n", "def show_audio(ad):\n", " sig,sr=ad\n", " display(Audio(data=sig, rate=sr))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def show_audio_in_out(orig, trans):\n", " \"\"\"Helper to plot input and output signal in different colors\"\"\"\n", " osig,osr = orig\n", " tsig,tsr = trans\n", " print(\"↓ Original ↓\")\n", " show_audio(orig)\n", " print(\"↓ Transformed ↓\")\n", " show_audio(trans)\n", " if orig is not None: plt.plot(osig[0], 'm', label=\"Orig.\")\n", " if trans is not None: plt.plot(tsig[0], 'c', alpha=0.5, label=\"Transf.\")\n", " plt.legend()\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### toCuda" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The other transforms both use all-tensor ops, so it should help. Let's try it out." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class ToCuda(Transform):\n", " _order=10\n", " def __call__(self, ad):\n", " sig,sr = ad\n", " return (sig.cuda(), sr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([[ 0.0000e+00, 0.0000e+00, 0.0000e+00, ..., -6.1035e-05,\n", " 0.0000e+00, -3.3569e-04]], device='cuda:0'), 16000)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ToCuda()(ll.train[0][0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### PadOrTrim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`torchaudio` has one for this already. All we're doing is taking an argument in milliseconds rather than frames." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PadOrTrim(Transform):\n", " _order=11\n", " def __init__(self,msecs): self.msecs = msecs\n", " def __call__(self, ad): \n", " sig,sr = ad\n", " mx = sr//1000 * self.msecs\n", " return (transforms.PadTrim(mx)(sig), sr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Note - this won't work if you've already run the notebook all the way through, because `ll` now contains Tensors representing Spectrograms, not `(Signal, SampleRate)` tuples.*" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "↓ Original ↓\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "↓ Transformed ↓\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pt = PadOrTrim(3000) ## duration in milliseconds\n", "show_audio_in_out(ll.train[0][0], pt(ll.train[0][0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Signal shifting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Signal shifting is a useful augmentation which can be applied to the signal itself; it simply shifts the input to the left or right by some %. Intuitively, this is useful for classification, but perhaps not for predictive models, as it can change the temporal order of things when the end of the signal wraps around to the front.\n", "\n", "This implementation lightly adapted from the [original implementation](https://github.com/mogwai/fastai-audio/blob/sg-cache/Google%20Small%20ASR.ipynb) by [Harry Coultas Blum](https://github.com/mogwai/)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class SignalShift(Transform):\n", " _order=20\n", " def __init__(self, max_shift_pct=.6): self.max_shift_pct = max_shift_pct\n", " def __call__(self, ad):\n", " sig,sr = ad\n", " roll_by = int(random.random()*self.max_shift_pct*len(sig[0]))\n", " return (sig.roll(roll_by), sr)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "↓ Original ↓\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "↓ Transformed ↓\n" ] }, { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "shifter = SignalShift()\n", "show_audio_in_out(ll.train[0][0], shifter(ll.train[0][0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Spectrogram" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once we're done augmenting the signal directly, we want to convert our 1D signal to a 2D [spectrogram](https://en.wikipedia.org/wiki/Spectrogram).\n", "\n", "Luckily, `torchaudio` has functions for calculation & conversion to spectrograms. Let's wrap their functions." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class Spectrogrammer(Transform):\n", " _order=90\n", " def __init__(self, to_mel=True, to_db=True, n_fft=400, ws=None, hop=None, \n", " f_min=0.0, f_max=None, pad=0, n_mels=128, top_db=None, normalize=False):\n", " self.to_mel, self.to_db, self.n_fft, self.ws, self.hop, self.f_min, self.f_max, \\\n", " self.pad, self.n_mels, self.top_db, self.normalize = to_mel, to_db, n_fft, \\\n", " ws, hop, f_min, f_max, pad, n_mels, top_db, normalize\n", "\n", " def __call__(self, ad):\n", " sig,sr = ad\n", " if self.to_mel:\n", " spec = transforms.MelSpectrogram(sr, self.n_fft, self.ws, self.hop, self.f_min, \n", " self.f_max, self.pad, self.n_mels)(sig)\n", " else: \n", " spec = transforms.Spectrogram(self.n_fft, self.ws, self.hop, self.pad, \n", " normalize=self.normalize)(sig)\n", " if self.to_db:\n", " spec = transforms.SpectrogramToDB(top_db=self.top_db)(spec)\n", " spec = spec.permute(0,2,1) # reshape so it looks good to humans\n", " return spec" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Small helper to show a spectrogram." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def show_spectro(img, ax=None, figsize=(6,6), with_shape=True):\n", " if hasattr(img,\"device\") & str(img.device).startswith(\"cuda\"): img = img.cpu()\n", " if ax is None: _,ax = plt.subplots(1, 1, figsize=figsize)\n", " ax.imshow(img if (img.shape[0]==3) else img.squeeze(0))\n", " if with_shape: display(f'Tensor shape={img.shape}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Note - this won't work if you've already run the notebook all the way through, because `ll` now contains Tensors representing Spectrograms, not `(Signal, SampleRate)` tuples.*" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Tensor shape=torch.Size([1, 64, 169])'" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "speccer = Spectrogrammer(to_db=True, n_fft=1024, n_mels=64, top_db=80)\n", "show_spectro(speccer(ll.train[0][0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### SpecAugment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An implementation of the [SpecAugment data augmentation technique](https://arxiv.org/abs/1904.08779) from Google Brain, which was shown to improve on SOTA results for audio classification. Effectively, it masks some number of contiguous frequency bands or timesteps. The intuition is similar to [cutout](https://arxiv.org/abs/1708.04552) for \"normal\" images. See their [blog post](https://ai.googleblog.com/2019/04/specaugment-new-data-augmentation.html) for a good discussion.\n", "\n", "This implementation lightly adapted from both [Zach Caceres](https://github.com/zcaceres/) and [Harry Coultas Blum](https://github.com/mogwai/) & [Robert Bracco](https://forums.fast.ai/u/madeupmasters). Rather than static `F` or `T` parameters for a maximum width of the masks per the paper, we're taking a \"maximum mask %\" and calculating the `F` and `T` from that.\n", "\n", "This does not attempt to implement the \"time warping\" augmentation from the paper, as it is not directly supported by pytorch, and provides only modest gains for considerable computational cost. [Zach Caceres's SpecAugment implementation](https://github.com/zcaceres/spec_augment) provides a full implementation of time warping." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class SpecAugment(Transform):\n", " _order=99\n", " def __init__(self, max_mask_pct=0.2, freq_masks=1, time_masks=1, replace_with_zero=False):\n", " self.max_mask_pct, self.freq_masks, self.time_masks, self.replace_with_zero = \\\n", " max_mask_pct, freq_masks, time_masks, replace_with_zero\n", " if not 0 <= self.max_mask_pct <= 1.0: \n", " raise ValueError( f\"max_mask_pct must be between 0.0 and 1.0, but it's {self.max_mask_pct}\")\n", "\n", " def __call__(self, spec):\n", " _, n_mels, n_steps = spec.shape\n", " F = math.ceil(n_mels * self.max_mask_pct) # rounding up in case of small %\n", " T = math.ceil(n_steps * self.max_mask_pct)\n", " fill = 0 if self.replace_with_zero else spec.mean()\n", " for i in range(0, self.freq_masks):\n", " f = random.randint(0, F)\n", " f0 = random.randint(0, n_mels-f)\n", " spec[0][f0:f0+f] = fill\n", " for i in range(0, self.time_masks):\n", " t = random.randint(0, T)\n", " t0 = random.randint(0, n_steps-t)\n", " spec[0][:,t0:t0+t] = fill\n", " return spec" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Tensor shape=torch.Size([1, 64, 169])'" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "masker = SpecAugment(freq_masks=2,time_masks=2,max_mask_pct=0.1)\n", "show_spectro(masker(speccer(ll.train[0][0])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using the transforms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's create the transforms with the params we want, and rebuild our label lists using them. \n", "\n", "Note that now the items in the final `LabelList` won't be tuples anymore, they'll just be tensors. This is convenient for actually using the data, but it means you can't really go back and listen to your audio anymore. We can probably find a way around this, but let's press on for now." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pad_3sec = PadOrTrim(3000)\n", "shifter = SignalShift()\n", "speccer = Spectrogrammer(n_fft=1024, n_mels=64, top_db=80)\n", "masker = SpecAugment(freq_masks=2, time_masks=2, max_mask_pct=0.1)\n", "\n", "tfms = [ToCuda(), shifter, pad_3sec, speccer, masker]\n", "\n", "al = AudioList.from_files(path, tfms=tfms)\n", "sd = SplitData.split_by_func(al, partial(random_splitter, p_valid=0.2))\n", "ll = label_by_func(sd, speaker_labeler, proc_y=CategoryProcessor())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Tensor shape=torch.Size([1, 64, 94])'" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "show_spectro(ll.train[4][0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Databunch" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we've got our beautifully transformed tensors, let's add them into a databunch, so we can feed a model easily.\n", "\n", "We can use our `get_dls` func which we defined in `03_minibatch_training`, but let's use the to_databunch func we defined in `08_data_block` instead, it's much nicer." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "bs=64\n", "\n", "c_in = ll.train[0][0].shape[0]\n", "c_out = len(uniqueify(ll.train.y))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "data = ll.to_databunch(bs,c_in=c_in,c_out=c_out)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check the dataloader's batching functionality." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,y = next(iter(data.train_dl))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we're overriding `10_augmentation`'s `show_batch` method to take a \"shower\" function so we can give it a spectrogram shower." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def show_batch(x, c=4, r=None, figsize=None, shower=show_image):\n", " n = len(x)\n", " if r is None: r = int(math.ceil(n/c))\n", " if figsize is None: figsize=(c*3,r*3)\n", " fig,axes = plt.subplots(r,c, figsize=figsize)\n", " for xi,ax in zip(x,axes.flat): shower(xi, ax)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "show_spec_batch = partial(show_batch, c=4, r=2, figsize=None, \n", " shower=partial(show_spectro, with_shape=False))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "show_spec_batch(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Looking good." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Training" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Go for gold! As a proof of concept, let's use the *pièce de résistance* learner builder with the hyperparameters from Lesson 11 `11_train_imagenette`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "opt_func = adam_opt(mom=0.9, mom_sqr=0.99, eps=1e-6, wd=1e-2)\n", "loss_func = LabelSmoothingCrossEntropy()\n", "lr = 1e-2\n", "pct_start = 0.5\n", "phases = create_phases(pct_start)\n", "sched_lr = combine_scheds(phases, cos_1cycle_anneal(lr/10., lr, lr/1e5))\n", "sched_mom = combine_scheds(phases, cos_1cycle_anneal(0.95,0.85, 0.95))\n", "cbscheds = [ParamScheduler('lr', sched_lr), \n", " ParamScheduler('mom', sched_mom)]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn = cnn_learner(xresnet34, data, loss_func, opt_func)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
epochtrain_losstrain_accuracyvalid_lossvalid_accuracytime
01.2110280.7136411.7214110.61943300:12
10.8830240.8726222.3180420.50337400:11
20.8085990.9068040.8892840.87449400:11
30.6749730.9609800.6529700.96356300:11
40.6040550.9819410.5977880.98380600:12
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "learn.fit(5, cbs=cbscheds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Demo - all at once" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is all the code it takes to do it end-to-end (not counting the `#export` cells above)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# dsid = \"ST-AEDS-20180100_1-OS\"\n", "# data_url = f'http://www.openslr.org/resources/45/{dsid}' # actual URL has .tgz extension but untar_data doesn't like that\n", "# path = Path.home() / Path(f\".fastai/data/{dsid}/\")\n", "# datasets.untar_data(data_url, dest=path)\n", "\n", "# pad_3sec = PadOrTrim(3000)\n", "# shifter = SignalShift()\n", "# speccer = Spectrogrammer(n_fft=1024, n_mels=64, top_db=80)\n", "# masker = SpecAugment(freq_masks=2, time_masks=2, max_mask_pct=0.1)\n", "\n", "# tfms = [ToCuda(), shifter, pad_3sec, speccer, masker]\n", "# al = AudioList.from_files(path, tfms=tfms)\n", "\n", "# sd = SplitData.split_by_func(al, partial(random_splitter, p_valid=0.2))\n", "\n", "# label_pat = r'/([mf]\\d+)_'\n", "# speaker_labeler = partial(re_labeler, pat=label_pat)\n", "# ll = label_by_func(sd, speaker_labeler, proc_y=CategoryProcessor())\n", "\n", "# bs=64\n", "# c_in = ll.train[0][0].shape[0]\n", "# c_out = len(uniqueify(ll.train.y))\n", "\n", "# data = ll.to_databunch(bs,c_in=c_in,c_out=c_out)\n", "\n", "# opt_func = adam_opt(mom=0.9, mom_sqr=0.99, eps=1e-6, wd=1e-2)\n", "# loss_func = LabelSmoothingCrossEntropy()\n", "# lr = 1e-2\n", "# pct_start = 0.5\n", "# phases = create_phases(pct_start)\n", "# sched_lr = combine_scheds(phases, cos_1cycle_anneal(lr/10., lr, lr/1e5))\n", "# sched_mom = combine_scheds(phases, cos_1cycle_anneal(0.95,0.85, 0.95))\n", "# cbscheds = [ParamScheduler('lr', sched_lr), \n", "# ParamScheduler('mom', sched_mom)]\n", "\n", "# learn = cnn_learner(xresnet34, data, loss_func, opt_func)\n", "# learn.fit(5, cbs=cbscheds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fin" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "nb_auto_export()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }