{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Adversarial Audio Examples\n", "\n", "This notebook demonstrates how to use the ART library to create adversarial audio examples.\n", "\n", "---\n", "\n", "## Preliminaries\n", "\n", "Before diving into the different steps necessary, we walk through some initial work steps ensuring that the notebook will work smoothly. We will \n", "\n", "1. set up a small configuration cell,\n", "2. check if the test data and pretrained model are available or otherwise download them\n", "3. define some necessary Python classes to handle the data.\n", "\n", "**Important note:** This notebook requires `torch==1.4.0`, `torchvision==0.5.0` and `torchaudio==0.4.0`." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [], "source": [ "import glob\n", "import os\n", "\n", "import IPython.display as ipd\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "import torchaudio\n", "\n", "\n", "\n", "from art.attacks.evasion import ProjectedGradientDescent\n", "from art.estimators.classification import PyTorchClassifier\n", "from art import config\n", "from art.defences.preprocessor import Mp3Compression\n", "from art.utils import get_file\n", "\n", "OUTPUT_SIZE = 8000\n", "ORIGINAL_SAMPLING_RATE = 48000\n", "DOWNSAMPLED_SAMPLING_RATE = 8000\n", "\n", "# set global variables\n", "AUDIO_DATA_PATH = os.path.join(config.ART_DATA_PATH, \"audiomnist/test\")\n", "AUDIO_MODEL_PATH = os.path.join(config.ART_DATA_PATH, \"adversarial_audio_model.pt\")\n", "\n", "# set seed\n", "np.random.seed(123)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# download AudioMNIST data and pretrained model\n", "get_file('adversarial_audio_model.pt', 'https://www.dropbox.com/s/o7nmahozshz2k3i/model_raw_audio_state_dict_202002260446.pt?dl=1')\n", "get_file('audiomnist.tar.gz', 'https://api.github.com/repos/soerenab/AudioMNIST/tarball');" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "%%bash -s \"$AUDIO_DATA_PATH\" \"$ART_DATA_PATH\"\n", "mkdir -p $1\n", "tar -xf $2/audiomnist.tar.gz \\\n", " -C $1 \\\n", " --strip-components=2 */data \\\n", " --exclude=**/*/{01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48}" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# dataloader and preprocessing classes.\n", "class AudioMNISTDataset(torch.utils.data.Dataset):\n", " \"\"\"Dataset object for the AudioMNIST data set.\"\"\"\n", " def __init__(self, root_dir, transform=None, verbose=False):\n", " self.root_dir = root_dir\n", " self.audio_list = sorted(glob.glob(f\"{root_dir}/*/*.wav\"))\n", " self.transform = transform\n", " self.verbose = verbose\n", "\n", " def __len__(self):\n", " return len(self.audio_list)\n", "\n", " def __getitem__(self, idx):\n", " audio_fn = self.audio_list[idx]\n", " if self.verbose:\n", " print(f\"Loading audio file {audio_fn}\")\n", " waveform, sample_rate = torchaudio.load_wav(audio_fn)\n", " if self.transform:\n", " waveform = self.transform(waveform)\n", " sample = {\n", " 'input': waveform,\n", " 'digit': int(os.path.basename(audio_fn).split(\"_\")[0])\n", " }\n", " return sample\n", "\n", "\n", "class PreprocessRaw(object):\n", " \"\"\"Transform audio waveform of given shape.\"\"\"\n", " def __init__(self, size_out=OUTPUT_SIZE, orig_freq=ORIGINAL_SAMPLING_RATE,\n", " new_freq=DOWNSAMPLED_SAMPLING_RATE):\n", " self.size_out = size_out\n", " self.orig_freq = orig_freq\n", " self.new_freq = new_freq\n", "\n", " def __call__(self, waveform):\n", " transformed_waveform = _ZeroPadWaveform(self.size_out)(\n", " _ResampleWaveform(self.orig_freq, self.new_freq)(waveform)\n", " )\n", " return transformed_waveform\n", "\n", "\n", "class _ResampleWaveform(object):\n", " \"\"\"Resample signal frequency.\"\"\"\n", " def __init__(self, orig_freq, new_freq):\n", " self.orig_freq = orig_freq\n", " self.new_freq = new_freq\n", "\n", " def __call__(self, waveform):\n", " return self._resample_waveform(waveform)\n", "\n", " def _resample_waveform(self, waveform):\n", " resampled_waveform = torchaudio.transforms.Resample(\n", " orig_freq=self.orig_freq,\n", " new_freq=self.new_freq,\n", " )(waveform)\n", " return resampled_waveform\n", "\n", "\n", "class _ZeroPadWaveform(object):\n", " \"\"\"Apply zero-padding to waveform.\n", "\n", " Return a zero-padded waveform of desired output size. The waveform is\n", " positioned randomly.\n", " \"\"\"\n", " def __init__(self, size_out):\n", " self.size_out = size_out\n", "\n", " def __call__(self, waveform):\n", " return self._zero_pad_waveform(waveform)\n", "\n", " def _zero_pad_waveform(self, waveform):\n", " padding_total = self.size_out - waveform.shape[-1]\n", " padding_left = np.random.randint(padding_total + 1)\n", " padding_right = padding_total - padding_left\n", " padded_waveform = torch.nn.ConstantPad1d(\n", " (padding_left, padding_right),\n", " 0\n", " )(waveform)\n", " return padded_waveform" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# RawAudioCNN model class\n", "class RawAudioCNN(nn.Module):\n", " \"\"\"Adaption of AudioNet (arXiv:1807.03418).\"\"\"\n", " def __init__(self):\n", " super().__init__()\n", " # 1 x 8000\n", " self.conv1 = nn.Sequential(\n", " nn.Conv1d(1, 100, kernel_size=3, stride=1, padding=2),\n", " nn.BatchNorm1d(100),\n", " nn.ReLU(),\n", " nn.MaxPool1d(3, stride=2))\n", " # 32 x 4000\n", " self.conv2 = nn.Sequential(\n", " nn.Conv1d(100, 64, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(64),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 64 x 2000\n", " self.conv3 = nn.Sequential(\n", " nn.Conv1d(64, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 1000\n", " self.conv4 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 500\n", " self.conv5 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 250\n", " self.conv6 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 125\n", " self.conv7 = nn.Sequential(\n", " nn.Conv1d(128, 64, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(64),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 64 x 62\n", " self.conv8 = nn.Sequential(\n", " nn.Conv1d(64, 32, kernel_size=3, stride=1, padding=0),\n", " nn.BatchNorm1d(32),\n", " nn.ReLU(),\n", " # maybe replace pool with dropout here\n", " nn.MaxPool1d(2, stride=2))\n", "\n", " # 32 x 30\n", " self.fc = nn.Linear(32 * 30, 10)\n", "\n", " def forward(self, x):\n", " x = self.conv1(x)\n", " x = self.conv2(x)\n", " x = self.conv3(x)\n", " x = self.conv4(x)\n", " x = self.conv5(x)\n", " x = self.conv6(x)\n", " x = self.conv7(x)\n", " x = self.conv8(x)\n", " x = x.view(x.shape[0], 32 * 30)\n", " x = self.fc(x)\n", " return x" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def display_waveform(waveform, title=\"\", sr=8000):\n", " \"\"\"Display waveform plot and audio play UI.\"\"\"\n", " plt.figure()\n", " plt.title(title)\n", " plt.plot(waveform)\n", " ipd.display(ipd.Audio(waveform, rate=sr))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Model and Test Data\n", "\n", "In the following section we are going to load the pretrained model that we downloaded in the previous section. Let's also load the test data set from which we will generate adversarial examples." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# load AudioMNIST test set\n", "audiomnist_test = AudioMNISTDataset(\n", " root_dir=AUDIO_DATA_PATH,\n", " transform=PreprocessRaw(),\n", ")\n", "\n", "# load pretrained model\n", "model = RawAudioCNN()\n", "model.load_state_dict(\n", " torch.load(AUDIO_MODEL_PATH, map_location=\"cpu\")\n", ")\n", "model.eval();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create Adversarial Examples\n", "\n", "After loading the test set and model, we are ready to employ the ART library. We will first load a sample, which here will have label 1. The classification model correctly classifies it as such. We will then use ART and perform a Projected Gradient Descent attack. The attack will corrupt the spoken audio and will be misclassified as 9. However, there is almost no hearable difference in the original audio file and the adversarial audio file." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# wrap model in a ART classifier\n", "classifier_art = PyTorchClassifier(\n", " model=model,\n", " loss=torch.nn.CrossEntropyLoss(),\n", " optimizer=None,\n", " input_shape=[1, DOWNSAMPLED_SAMPLING_RATE],\n", " nb_classes=10,\n", " clip_values=(-2**15, 2**15 - 1)\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original prediction (ground truth):\t1 (1)\n", "Adversarial prediction:\t\t\t9\n" ] } ], "source": [ "# load a test sample\n", "sample = audiomnist_test[3559]\n", "\n", "waveform = sample['input']\n", "label = sample['digit']\n", "\n", "# craft adversarial example with PGD\n", "epsilon = .2\n", "pgd = ProjectedGradientDescent(classifier_art, eps=epsilon)\n", "adv_waveform = pgd.generate(\n", " x=torch.unsqueeze(waveform, 0).numpy()\n", ")\n", "\n", "# evaluate the classifier on the adversarial example\n", "with torch.no_grad():\n", " _, pred = torch.max(model(torch.unsqueeze(waveform, 0)), 1)\n", " _, pred_adv = torch.max(model(torch.from_numpy(adv_waveform)), 1)\n", "\n", "# print results\n", "print(f\"Original prediction (ground truth):\\t{pred.tolist()[0]} ({label})\")\n", "print(f\"Adversarial prediction:\\t\\t\\t{pred_adv.tolist()[0]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We observe that for the given test sample, the model correctly classified it as **1**. Applying PGD, we can create an adversarial example that is now classified as **9**.\n", "\n", "Now we can qualitatively explore the result." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": true }, "outputs": [ { "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": [ "# display adversarial example\n", "display_waveform(adv_waveform[0,0,:], title=f\"Adversarial Audio Example (classified as {pred_adv.tolist()[0]} instead of {pred.tolist()[0]})\")" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "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": [ "# display original example\n", "display_waveform(waveform.numpy()[0,:], title=f\"Original Audio Example (correctly classified as {pred.tolist()[0]})\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's create a second adversarial example." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original prediction (ground truth):\t5 (5)\n", "Adversarial prediction:\t\t\t6\n" ] } ], "source": [ "# load a test sample\n", "sample = audiomnist_test[3773]\n", "\n", "waveform = sample['input']\n", "label = sample['digit']\n", "\n", "# craft adversarial example with PGD\n", "epsilon = 0.5\n", "pgd = ProjectedGradientDescent(classifier_art, eps=epsilon)\n", "adv_waveform = pgd.generate(\n", " x=torch.unsqueeze(waveform, 0).numpy()\n", ")\n", "\n", "# evaluate the classifier on the adversarial example\n", "with torch.no_grad():\n", " _, pred = torch.max(model(torch.unsqueeze(waveform, 0)), 1)\n", " _, pred_adv = torch.max(model(torch.from_numpy(adv_waveform)), 1)\n", "\n", "# print results\n", "print(f\"Original prediction (ground truth):\\t{pred.tolist()[0]} ({label})\")\n", "print(f\"Adversarial prediction:\\t\\t\\t{pred_adv.tolist()[0]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we observe that for the given test sample, the model correctly classified it as **5**. Applying PGD, we can create an adversarial example that is now classified as **6**." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "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": [ "# display adversarial example\n", "display_waveform(adv_waveform[0,0,:], title=f\"Adversarial Audio Example (classified as {pred_adv.tolist()[0]} instead of {pred.tolist()[0]})\")" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAEICAYAAAC3Y/QeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2deZgUxfnHPy/LfZ8ici0gqHiguCKK4oUKGEWjJhh/3opnjImJAW+jJMZ4JMZ4oFHxjjEqKngAHniAuCjKLSsscrOA3Pdu/f7omt2enu45dmd2Zrffz/PMM93V1d3v9HR/u+qtt6rEGIOiKIoSLupk2wBFURSl+lHxVxRFCSEq/oqiKCFExV9RFCWEqPgriqKEEBV/RVGUEKLinyIicrOIPJXuvEkcy4jIvuk4VhLnelZE7rHLx4rIguo4bzYQkeNFZFkV9j9VRN5Mp02ZRkTy7f1UN43HrNJ1TOL4j4vIba71q0VktYhsEZE29rt7JY9dbc9WwPl/LSJ/re7zhlr8ReRiEZklIttEZJWIPCYiLePtY4z5szHm8mSOn0redGBFe4+IdEjXMY0xnxpj9qukPR+LyA77YEY+b6fLthxhNHBvto2Ih4gUi8igbNtRFYwxVxlj7gYQkXrAg8Apxpimxph19ntRdq0Mxv4H213PwQeuzU8C54vIXtVpU2jFX0RuBP4K/AFoAfQHugITRaR+wD5pKymlGxFpApwNbAT+L8vmuLnOPpiRz+nZNihdiMgRQAtjzLQ0HzfmPsvley8LtAcaAnOybUiKnO56Dk6JJBpjdgDvAhdWpzGhFH8RaQ7cBfzaGPOeMWa3MaYY+AWQjxVPEblTRF4TkRdEZBNwsU17wXWsC0VkiYisE5Hb3KUsd15XVfsiEflRRNaKyC2u4/QTkakiskFEVorII0EvoQDOBjYAfwIu8vzecjeOXY+qoovIYSLytYhsFpH/4DxYQXkPsCX6DSIyR0TOSMFGt01/FJEvI6Jmq/FzRKShXf+vrY1tFJEpInKg5/c8KiLv2lLU5yKyt4j8XUR+EpH5InKYK3+xiIwSkbl2+zOR8/jYtY+I/E9ESkRksYhcH+dnDAE+8ex/oIhMFJH11i1xs01vYO1bYT9/F5EGdtvxIrLMXpNVwDMB914LEfm3vT+Wi8g9IpLnOvcVIjLP/o9zRaSviDwPdAHettfqJo+954rIDE/a70RkXMD1aW2v3wp7LX1dXiIyUkR+cNlylmvbviLyif1v19p7DnF4SETWiMgmcWrlB9ltz9rf2wuIuCE3iMiHdnu568Ze6/vtc7ZaHJdRI9f5/2Cv4QoRuTTgv43kvcR1TReJyJWubW1F5B37LKwXkU9FpLKa+jFwWiX3rRzGmNB9gMHAHqCuz7axwMt2+U5gN3AmzouykU17wW7vDWwBjgHqA/fb/INc+0fy5gMGp4rXCOgD7AQOsNsPx6l91LV55wE3uOwywL5xftNk4D6cUtEe4HDXtmeBe1zrxwPL7HJ9YAnwW6AecI79Dff45K0HFAE32/1OBDYD+wXY9DFwecC2OsAUe416Aj8Bh7m2Xwo0AxoAfwdmen7PWnvNGgIfAotxSk55wD3AR678xcBsoDPQGvg84PfVAWYAt9vf1x1YBJwa8Bv+C/zBtd4MWAncaO1qBhxpt/0JmAbsBbQDvgDudtmwB6cm2oCK+8x7770BPAE0sceZDlxpj3EusBw4AhBgX6Cr6/cPctmZj3M/1bXnW4+9D+32b4CzA37zeOA/QCt7PxznvY4ue/axtv8S2Ap0sNteBm6x2xoCx9j0U+31b2l/wwGufZ51/Wfl9vs9H8BDwFv2v24GvA38xfXsrwYOstfxJeI8WziC3MPacxywDehrt/0FeNxeh3rAsYAEHKfYnrcE+ADo49neF1hfrTpYnSfLlQ9OyX5VwLZ7gYl2+U5gimf7nVQI+u3YF4VdbwzsIr74d3Llnw4MD7DjBuANv5vbJ28XoAw41K6/D/zDtb38wbHr5Q8qMBBY4b5pcYTJTxyPBVYBdVx5XwbuDLDrY/uwbHB97nZtz8cRnnnAqDj/V0v7+1u4fs+Tru2/Bua51g8GNrjWi4GrXOtDgR98ft+RwI+ec48Cngmwa6LnuOcB3wTk/QEY6lo/FSh22bALaOi5z6a41tvjFBYaec73kes//03AuYsJEH+7/hgw2i4fiPMibuBznA72Pmvls638OgbYMBMYZpefA8bgehZs+onA9ziFoDqebc+ShPjjiPRWoIdr21HAYrv8NHCva1svEhSsPHa8GbnOOC/0ccnsCwzAeYE3tvfUKqCla3tPoDQZG9L1CaXbB6fU2Fb8/agd7PYIS+McZx/3dmPMNmBdgnOvci1vA5oCiEgvW4VcZav5fwbaJjhWhAtwxG+mXX8R+JU4DWOJ2AdYbuwdaFkSJ+9SY0yZJ2/HOMe/3hjT0vUpj9gwjqvtI5yH+V+RdBHJE5F7rdtgE454QfT1WO1a3u6z3tRjh/t/XGJ/i5euwD62Gr9BRDbg1HLaB/y2n3BKlhE644i8H/sQfV29NpQYx/cbZHNXnNLlSpdtT+DUABKdOxFjce4XwbmXXjXG7PTJ1xmndPpTogOK4w6d6bL1ICr+v5twRHq6OK6+SwGMMR8Cj+DcC2tEZIw4LtpUaIcjsDNc537PpoPnmSX4Xo/8jiEiMs26dTbgFBwiv+NvODXhD6xLaGTQcYwxnxtjthtjthlj/oJTEDrWlaUZTntdtRFW8Z+KU4r6uTtRRJri+HEnu5LjDXu6Eujk2r8R0KaSNj0GzAd6GmOa44iOJLnvhUB3++JYhRMJ0RbnRgWnJNTYlX9v1/JKoKN98CN0CTjPCqCzx6/ZBcfdkDIichpOqWwyzoMU4VfAMGAQTmN8fmSXypzH0tm13AXnt3hZilNCdL+smhljhvrkBfgOp+To3j8o3HAFjoAH2eB3n7nTluLcs21dtjU3xhzo2t4j4Nzx7mGM02C9C0eMfgU8H5B1KdBaEkTEiUhXHPfmdUAbY0xLHLeb2POtMsZcYYzZB7gSeDTirzfGPGyMORzHpdoLJyAjFdbivPwPdF2nFsaYSGFgJbH3QtDvaAD8D8ed297+jgmu37HZGHOjMaY7cAbwOxE5KUk7DdH38wHAt0numxZCKf7GmI04Db7/FJHBIlJPRPKBV4FlBN/8Xl4DTheRo8VpnL2TygtUM2ATsEVE9geuTmYnETkK56HvBxxqPwfh+DIj0QMzgaG2sW5vHJdShKk4/ubr7XX4uT2WH1/i1FZusnmPB04HXkn6V1bY3RZ4Crgcp4H6dBGJiGwzHKFbh/PS+nOqx/fhWhHpJCKtcfzN//HJMx3YLE7DayNbAzlInKgePybg+IEjvAN0EJEbbKNjMxE50m57GbhVRNrZ33478AJJYoxZieMrfkBEmotIHRHpISKR8z8F/F5EDrcNp/taEQanVpQoBv45nFL3bmPMZ3FseBdHrFvZe2CgT9YmOOJWAk6jKc49iV0/V0QihaafbN4yETlCRI60NdatwA4cN1PS2Frpk8BDYkMnRaSjiJxqs7yK03jeW0QaA3fEOVx9nDaREmCPiAwByqN0RORn9joLTqm91M9eEekiIgNEpL6INBSRP+AUzj53ZTsO59pWG6EUfwBjzH04pev7cUT3S5ySzUkBVV6/Y8zB8Te/glOi2AKswRGuVPk9TqlrM87N6ydOflwEjDPGzLIlqlXGmFXAP4CfWbF7HqdUUYwjIOXHNsbswqkBXYzjf/8l8LrfiWze03FqR2uBR4ELjTHz49j3iETH+UciS8ZYuycYY9YBlwFPiUgbHCFaglOjmIvTUFpVXsL57Ytw3CP3eDMYY0qBn+G8QBfb3/gUTu0jBmPM18DGiMAbYzYDJ+Nco1XAQuAEm/0eoBCntjAL+NrPhgRciCNIc3FE8zUcNyXGmP/i9Dl4CeceehOnwROchslbrRvk9wHHfh5HoBO9kC7AaYiej3Ov3+DNYIyZCzyAU7BYjdMG4xa6I4AvRWQLTsPsb4wTo98c597/Cef/X0d0jTBZ/ojjjplm3YaTgP2sbe/iBBB8aPN8GHQQ+39ej/PC+Ann+XzLlaWnPfYW+1sfNcZ85HOoZjg1+59w7unBwBB73yNO5NlQHPdbtSHRrl6lKli30QYc183ibNujOIhIMU7U0aQMHPsU4BpjzJnpPnZ1Yl2Wa3AiWRZm254wISK/BjobY25KmDmNaMeRKiIip+P4rAWnFjGLigZKpZZjjPkAp0ZR07ka+EqFv/oxxvwzG+dV8a86w3CqzIJTrR9utDql1CBszUhw+hQoIUHdPoqiKCEktA2+iqIoYabGuH3atm1r8vPzs22GoihKjWHGjBlrjTHt/LbVGPHPz8+nsLAw22YoiqLUGEQksAezun0URVFCiIq/oihKCFHxVxRFCSEq/oqiKCFExV9RFCWEqPgriqKEEBV/RVGUEKLir4SSCbNWsn7rrmyboShZQ8VfCR1rNu/gmhe/5qrnZyTOrCi1FBV/JXTs2uNMtrR8w/YsW6Io2UPFX1EUJYSo+CuKooQQFX8ltOhcFkqYUfFXQoeIZNsERck6Kv5K6NASv6Ko+CshRmsASphR8VcURQkhKv5KaFH3jxJmVPyV0KHuHkVR8VcURQklVRZ/EeksIh+JyFwRmSMiv7HprUVkoogstN+tbLqIyMMiUiQi34lI36raoCiKoqRGOkr+e4AbjTG9gf7AtSLSGxgJTDbG9AQm23WAIUBP+xkBPJYGGxRFUZQUqLL4G2NWGmO+tsubgXlAR2AYMNZmGwucaZeHAc8Zh2lASxHpUFU7FEVRlORJq89fRPKBw4AvgfbGmJV20yqgvV3uCCx17bbMpvkdb4SIFIpIYUlJSTpNVRRFCTVpE38RaQr8D7jBGLPJvc04MXUpx9UZY8YYYwqMMQXt2rVLk6WKoihKWsRfROrhCP+LxpjXbfLqiDvHfq+x6cuBzq7dO9k0RalWVmzcQcE9k9iyc0+2TVGUaicd0T4C/BuYZ4x50LXpLeAiu3wRMM6VfqGN+ukPbHS5hxQl47ij/Ndu2cn8lZsC8ypKbaVuGo4xALgAmCUiM23azcC9wKsichmwBPiF3TYBGAoUAduAS9Jgg6IkjfbrVZQ0iL8x5jOiC1NuTvLJb4Brq3peRVEUpfJoD19FUZQQouKvKIoSQlT8ldDh9VHqOG9KGFHxVxRFCSEq/oqiKCFExV8JPTqnixJGVPwVRVFCiIq/Enq0wVcJIyr+iqIoIUTFX1EUJYSo+Cu1lhemLeGXT0zNthmKkpOkY2A3RclJbn1zdpI51emvhA8t+SuKooQQFX9FUZQQouKvKDrCvxJCVPyV0KFx/YqSvjl8nxaRNSIy25V2p4gsF5GZ9jPUtW2UiBSJyAIROTUdNihK5dG3gRI+0lXyfxYY7JP+kDHmUPuZACAivYHhwIF2n0dFJC9NdiiKoihJkBbxN8ZMAdYnmX0Y8IoxZqcxZjHOXL790mGHoiSDDuSmKJn3+V8nIt9Zt1Arm9YRWOrKs8ymKUrGmLNiI5ePLWR3aVm2TVGUnCCT4v8Y0AM4FFgJPJDqAURkhIgUikhhSUlJuu1TQsSNr37LpHmr+X71Zm3wVRQyKP7GmNXGmFJjTBnwJBWuneVAZ1fWTjbN7xhjjDEFxpiCdu3aZcpUJQTUsYrv5/LRl4ESRjIm/iLSwbV6FhCJBHoLGC4iDUSkG9ATmJ4pOxQFKgTeT/xveu07fv/fb6vXIEXJMmkZ20dEXgaOB9qKyDLgDuB4ETkUpwdNMXAlgDFmjoi8CswF9gDXGmNK02GHogRRXvL36dBVtGYLRWu2cP+5farbLEXJGmkRf2PMeT7J/46TfzQwOh3nVpRkiJT8yzTSR1EA7eGrhISIW99onKeiACr+Slgod/soigIq/kpIkKjl4PCeD+asIn/keNZs3pF5oxQli6j4K4qlZPNOnv2iGIB5Kzdn1xhFyTA6k5eiWI4YPSnbJihKtaElfyUUuH392qlLUVT8lZAh6MBuigIq/oqSEmVlhjLtLKDUAlT8lVBhSM7tE5TlgNvf44QHPk6jRYqSHVT8lVCQqpvfXbYvWrO5vHPYzj1lLFm3LW12KUq2UPFXQkFlHTVTvi9h0INTeG3GsrTaoyjZRsVfCRVCarWAojVbAJizYlNG7FGUbKFx/kroSKYWIMBFT0+nsDjZ2UkVpWahJX9FCeCT70vYussZbXzi3NVZtkZR0ouKvxIqDKk3/gIs37CdaYvWpdscRckaKv5KrWT7ruj5gdLRqVddQEptQsVfqZUccPt7UeupRvv8ULIlJu3+D76vgkWKklukRfxF5GkRWSMis11prUVkoogstN+tbLqIyMMiUiQi34lI33TYoCjJkGwN4K6352bUDkXJNukq+T8LDPakjQQmG2N6ApPtOsAQnEnbewIjgMfSZIOiBLKntAyApz5brBO6KAppEn9jzBTA6xAdBoy1y2OBM13pzxmHaUBLEemQDjsUJYjtu502gPHfrcyyJYqSG2TS59/eGBN50lYB7e1yR2CpK98ymxaDiIwQkUIRKSwpKcmcpUqtJ0/HcVaUKKqlwdc4A6OkXNs2xowxxhQYYwratWuXAcuUsFBHxV9Rosik+K+OuHPs9xqbvhzo7MrXyaYpSsYw6ulXlCgyKf5vARfZ5YuAca70C23UT39go8s9pChpZ9uuPTqBi6J4SMvYPiLyMnA80FZElgF3APcCr4rIZcAS4Bc2+wRgKFAEbAMuSYcNihLEfe8t0HK/onhIi/gbY84L2HSST14DXJuO8ypKMmzasTtqXWsBiqI9fJWQYFTxFSUKFX8lFKj0K0o0Kv5KOFD1V5QoVPyVWo8gqv2K4kHFX1EUJYSo+CuhwN3gqx2+FEXn8FVCwKR5q9m4fXfijIoSIrTkr9R6MiX8a7fs5NnPF2sYqVIj0ZK/EjpKNu9My3Guf/kbvvhhHUf1aMt+ezdLyzEVpbrQkr8SOs545PO0HGfDNqdGsdtOFKMoNQkVf0VRlBCi4q8oihJCVPwVpZLo/DBKTUbFX1EUJYSo+CuKooQQFX9FUZQQouKvKFlm+YbtlJVpRzGlesm4+ItIsYjMEpGZIlJo01qLyEQRWWi/W2XaDqVmsWrjDtZs2pFtM5KiKh18F6/dyoB7P+RfHxWlzyBFSYLqKvmfYIw51BhTYNdHApONMT2ByXZdUcrp/5fJ9Pvz5GybkXFWbtgOwAMTv+fXL3+TZWuUMJEtt88wYKxdHgucmSU7FCW7uMJF3/52RfbsUEJHdYi/AT4QkRkiMsKmtTfGrLTLq4D2fjuKyAgRKRSRwpKSkmowVUmWBas2pzRg2pwVGznjkc/YtmtPBq2qPrbs3MOcFZuqfJw62llAyRLVIf7HGGP6AkOAa0VkoHujcYZE9PWaGmPGGGMKjDEF7dq1qwZTlWQ59e9TGD5mWtL573lnHt8t28g3P27IoFXVx0F3vJ+W43jF/8d129JyXEVJRMbF3xiz3H6vAd4A+gGrRaQDgP1ek2k7lPQRGcJ43spNSUWprN2yk6mL1gGwSwdBi8Jb8B/4t4+yY4gSOjIq/iLSRESaRZaBU4DZwFvARTbbRcC4TNqhpJfLxxaWL//7s8UJ898xbk758iXPfKVhjS7C7PSZNHc1+SPH15iortpGpkv+7YHPRORbYDow3hjzHnAvcLKILAQG2XWlBrBy43Ymz6+oqC1ZvzVufmMM42etjEorq2WTn/hNCzn1h3Xs3FMauM+aTTv4omgtz09bkknTqsyaTTsozdDL+vLnnELE2KnFGTm+Ep+MTuZijFkE9PFJXweclMlzK6lRWLyew7u2QhI0QK7dvCtqXRKUXf2Eo3ZJf+w1mL9qE+c9OY0L+nfl7jMP8t1n4N8+Ysfu7LjASssMO3aX0qRB/Md/6fptHHvfR9StI9wwqCfXndizmixUqgPt4avw3uyVnPP4VLqNmpAw7wdzV0Wtb9oRP+JnysLYKK2/vjs/NQNrEGc/9gXXvPA1AJ8XreWjBf7NWfGEP3/keHbsDq41VJUeN0/gwDveTzgJzbH3Oe0Pe8oM93/wfcbs0Yin7KDiH3JWbNjOVVaskmF3aXS5feLc1XHzb9kZK2JPJWgnmL18Y9L2+JGuSJzKMGPJTyxa67jCFq3dyiXPfBUjssmEu74/Z1XCPFUlnvhv2ZnZkFyd9zj7qPiHnFcLlyadt6zMxHRE2rarlOW2l6oflXnI735nbsr7rN2ys3xu3kwLV6p4L0Hv2xO/nFo2rp8RW5JtbB/xXGHiTFVg4Zot5cv//FCHtsgGKv4h5++TFkatxyuVPjFlka/Qn/9kcLx/UOPu2i3Bk6h/uXh9+XKyL4+CeyZxxOhJSeVNN1t37eH71ZsDt/s1CCfiw3mrM9Ih7sXpP5Yvx7u0X/ywLu3ndhOZ/1jJHir+ShTxSqVf/LDWN704TseksgDPwpYd/sLmdfmM/aI48Nj+56t+d8IVYws55aEpgS+q/xYuY9Trs9ixu5Rh/0pu8vixU5dw8+uz0mkmALe9Obt8eeee9Dc4b9y2m/yR4/l2afzOfN5AgMLi9ezRPiDVioq/kjSVcdMGlV7XbPYv+XvbED5PogTqFt1EDdCZYLN1M7lrLG5ufXM2L0//kdnLNyYURTeRtoNMMf671MYSSmY4j5v+9y0A//fvL+Pm84r/OY9PDcVAfrmEir8SQ5BLpjIRKLe5Oni5+cUTU33Tve+XROfcunNPVJTSoX+amJJ96STRcBeJwmi9ZLo/RKqhpkf/Jb447yktY+Fqx5e/OaBmF+HNmctj0tZv3eWTs4Kde0q1dpBGVPyVGM4LELFqCcnzCN6nC/1dTRHmrwr2tecadVK8fEEus8ridUv97f0FCfd559fHlC/XqxtfLva95d2kaytFrgbfZNnv1vfY95Z3U95P8UfFX4lhYcCDmWrD5fxVqY96uTPFkl1NKglmu+Tv7Wm9q7QsYRvJQR1blC/Ha6RdVBJ7z3xeFPzinpmC+wuiX1xL1+vgd+lAxT/ExAvR9HP9pNqWGtSoG48nPlmUUv7RE+alfI5scWaSjb0REmn/6k07yB85ngNuey+p4133UuxkMT/6COkCT22qT6cWMXm8nPjAJzFp17yYfP+RCEFtNlNdbT9Xvzgj5eMqsaj45wjGGD5esCZuSWxRyRZ+8fhUitPUELgwTnji10t+iklLtSSa6sviT2+nHt//3bKqdQjLZRLVtI60DaTbd5eycmPwixyC+z489vEPMWmn/n1K1Ppx++0V99hBpDLfQ4SnAzoAzlxWUVOYvTxxjXLj9t05198j11DxzxEmzFrFxc98FXeQqxMf+ITpxes5/v6P03LOGT4CH8FPuOONxe/3oKXysjDG8PTn/g/+OJ/GQaic37gmEe/l6b0mN7wyM+6xXnHF97v5qtg/QsnNoZ0Tl/zThbffSYT73otun1idYCTQPnd9QME92Wv8rwmo+OcIs1c4Jdi7Akq/23dFR71c/ULVq77xelZ6q/6JOhyd8chnMWmJtL/EFe4ZT+h+EyBs5zz+RfwT1HCK1mwJFGfvNQkKM40QNI+Ct4HWrw3l4I4t4x47Vb5zleKfueSImO3xaqQR4hVEIu0DO3aXkT9yPEP/8WklrKz9qPjnCPu1bwZAt7ZNfLd7Szrvzq7a2C+J3AQPTYoeyMtb8vJSsim2jSCR28L9m1J1Ke3YXRqKXqLnPh4bEvvGN8t888ZzGe5ydeh69zfHBubb5gqtrZfnNFC3a9YgoZ2pcMYjFW0ffbu04shuraO2L3a9kHbsLvUteFz1wozAoaa9ndfmrqz6dJu1ERX/HKFt0wb2239Mlyc/dRpC7zi9d1rOt3JjahNozFkR7VsfMbA7/TwPrZdEer5wTUUJL9Ux47/+MdhlVdv57X++9U1/cGLwyJtu8W/TJHjcoLMfrahNHdcr1tf/g09UT1Vo0age/7nyKD774wnladtdL6Det78X2Ot8gid6KcK2XbF9Qx750N+dFGZU/HOMnwJKsy9+6fhs99u7WXnaFQkG33puajH5I8czymeYAL9SYqT24Yd3dM6bhx7AS5cfGZjfGMNzU4vj2ud2caUa1RjWYYDjvSQ/CwitLC0zPOpq2I1XkneH+f7tnENitr/8ZWzbQTqG1OjYslH58u2ujoHxDv3rl2Ojl8A/yiyTQ1LXVFT8c4SI28PPlbHKVUrvl9+ay4/pBsQfTnnx2q3lD9HL03+M8eWOmRIbUvnO9cfEpEUo9elxVDev4vbZ7Gnw/ar4J96fU2Hf6LMOIs/Ty8ktZKmW5PeUpjcGviZw2sOf0uPm4DkXgmLn3/gmunHY298gaEyi5o3qxaTt8VHju96uEOuZt59M0egh5evJvhjcNsWLEvrdyb2i1r09wHfsLtV5kJMka+IvIoNFZIGIFInIyGzZkSuU2gfQL77enVY3rw4jh+xfvj7+u9iqb/HarZzgiQjydvD5wPXi+PDG45g66kTq5QXfDqm6ZbwP5f57N2fQAdFuhM079pA/cjx/fW8+0xbFH8PHG92SaOyY2sTv//stxhjmrIj2XV97Qg9m33Vqwv23uGLnf3VkFwC+vLliIr1fPhHbo/u5S/tFvaxbW1fRHp9CwNipFVNRtmxcP6pQsLsK3ZT9XhzXn9STO12uz9dmRLd/hKEdKF1kRfxFJA/4FzAE6A2cJyLpcWbXUNylL2+kzY2vOj7eh37pzIjpfri8M2sBvqGgQREzAN3bNaVDi0aB2wF+KKl634K7h/lPafjYxz8kbPCNZ39t57UZy3zdgZcf052mCaZihGjXyfV2Ksb2zRuWp023EUXuDlbeRtbIi+DH9fEDBbxM90QhufuoHNuzre8+ERfQhoAawMGuTmdL1nmileK8bFZt3MGlz34V1f4RZjI6h28c+gFFdo5fROQVYBiQei+fBFz09PS4E2nnCj9trbjRH/24iH8MP6x8fYENfTul997lafP+NJgDbn8v4bjrpx3cIabU7+aPg/ePWm9ULy+qwQ2cSbzd3OfjC45QWmZ4d/ZKmjeMdhk0qFuHvVyC4yUyIFhlefriAjgbJb0AABksSURBVC59NrMTkGSTvnfHxqy3sqXxCdcfy9CHnXDGpeu30bl146h8y35KTrDd4ZNHdY8W5l8WdOaRj4qY8n30tJzuQsvhXVvFHHPMlEUc27Nd+bq7XeLMQztG5e3etgmL1m6lj+1X4B3G4Q+n7mfP05rfndyLByd+T74nOs4r7P27t6aga2se+aiI/nZgul63vssdp/eultnS0kGLRvV44oKCtB83W26fjoB7CqllNi0KERkhIoUiUlhSEjsXbDKUGUOZIec/LRrXK69aj5vpP9Sue8LtRvXzgNhG2g3bKkZGLL73NP51ft+41ycSzhehID/2Afb68889vFP58ul99ona9tzUYq576Rte/7qiOr5Pi4ZRY8T48UGC6SATsf/ezau0f02m9z4Vv92vLcc9R0KrJrF+/Ajue6dF4+h8Jx3g38vX7YryE3/vwHzu5oYDOkT/Z5HXyIRZjih7CzZXHdcjZvmWN2ZH5XH3Z2jfvAFjL+1Hr71jAxn+9/Uy5q/anPXnPplPpgZ3zVbJPymMMWOAMQAFBQWVugTPXxYckZKL5I8cH7UebyarY3u2jYqJBrjazsd7UMdYMfxx3Ta6tGkcdcwT949+qP92Tp/yEtK9786Pal+I4G6cq+9pJ1ht4/3HuaZ7PL9/18DfkAoTZq1k6MEdGHhfbINe2Jp/p406yTf9+WlLuPvMaPfaClefjgZ183z3K1qzhcfjjKuUyC0I0RFYR3Zr7dvxbN2WihdMs4bR8vPkhYcz6EFnaInzn5oW4/50t0HUd40wOmnuagb1bg9UlPwv6N+1/Dp099QOerVvyp5SQ7/81oy5MP0l6ppCtkr+y4HOrvVONk3xEKmyex9ocEpVy37aHlXVnWobTkcM7BGTf4d1f0X6DIDj73ezd4sK18zjnzjhgbe8ETyjlDfiMvJ8ut9ZDRIMBezFrwQJMG3ROmYv3+g7GFmjev6iVltx/0+JCHL7uMV30IOfMM92hhoxsHtM3paN/WsMkRoowM8O6VC+HHHReHH3RfC6p/bdq6KE/nnROtbaF8Vlx3Tj29tP8T0ewOWukOdIP4QB+1a4rTp4rtX3q7dQWmaomxfOcOEI2RL/r4CeItJNROoDw4G3smRLTtGrvSPGH8533CCRzlhdPQ+Km3VbndL2Jy5/7Cm2JARw788PBiomy/jzhPkp2TRtUeLxXyL4hd/XT1H881wHcYv6c1OX8LN/xg4jAU40yuvXHJ3SecLApwsr7ok5nsigs/t28mYHnAlyvDQMeLm6S/tu115BfvwOgF3bBN/PXoYf0TnGDRVEpAOcO3qsgY/tpWWGvDrhjnTPyq83xuwBrgPeB+YBrxpj/Kd8Chn9u7cBKG+8/MA2SnVsFVvtvu9sp+F1/kqnejzX+l+7tW0S9bBG5tgdPmZa1NC4yZAoxNOt9eu37kKIVf9jXKUw9+Qg8bh72IEAvHB5v6TygzNUQE0lEr74WII2miAuHdCtfNkdqXPBv6eXL3tDeW8eeoDvsX52yD6+6RHc90SiAdaCeCEFd2ydJGbBWbFhO/1GTypfv+CoClejX81z0dqt1E11dp1aRtZefcaYCcaYXsaYHsaY0dmyI9dw907csbuUp+wQt118Sv59OjsDbl3y7FdAxQviYVekEMBhXSoG5jrvyYqY7lYBpanfn1LRkSZepyIvfe+e6Fvyd7uWEjX8Rvi//l35+raTk2rIbR1nuIKawGd/PIGLB3RjwT2DGXJwB4Yf0TnxTh7cvXaDhkPwdrILqpElcoe4h3x+KM6QEvFIpRGzVWP//7ev677+54dFUfNC57ep8PPXy6vD/64+mqN7tIna39v5LWyEu96Tg9xlS7wA/5hcMR6JXwesyAuhc2tH9MfZm3mv5tHd9w/t7D8q49/O6eOb7tezM4JX3G88ZT/P9vSUpkSE1k3qxx3G4bhe7Zj3p8F8MfLEtJwzGzRrWJdOrZz/MdIYe+/ZhzDogPbxdoshmRnNki3o7u8THePGPZR2pFHXPTyDl0iHP3egQSoel6CX++vXDKBft9Yc0qkFL3uGrPa+6A7v2oqXrugfN0w5bKj45xjNGtbjPyP6A/4TbbhpVD+Ptk3r07ZpAx6c+D2T568BYhvn2jdvGFVKinBMQCebXnHG+MnziLG34TEdNemrT6horI73LvnbuYfQqH5eoD+6JhPvd/92UK+YNL8hm71jK/m9mP06iTVrmJx/3Y035NfN/re9R/7I8Uyet6Y8LfLCqyqtGteLmdBn9Fn+nQkBflGQeq2qtqLin4N4R8t87tJgv/faLbv45scNPOyqJfiF871+zYCYtCDRjLQ7+JFoQLWqdq9f9OehnOCaOSrekBPeF1FNJOgXBM1/3KdTC3594r4x6Ud2i/7P1mzeETVAWhA3DOqZME8Qha65BlrH6T8QYUkSc+9+d+cpMdE58fB2JgQ4Ks796+b6kyr/22sDKv45iIjwyR+OL18/snv8yAk3r155VAYsSp5nvyiu9L4XH50f07iXV0f44c9DffM3rp/T3VSS4o8+/SgAlgYMo9CwXp5vA6i3FvfJguQ6RZ6bQknYO9y4O4TUr03Ky93vJO7A37xhPd++JYH5fVyUQW0EEUafdRD9urXmBhV/JRfp2qYJ0285ick3HhfYMQdg1p3R8c/xxtif8oeKMdP/YsM/U8XPVxvUcAzEDOYWj9t/5j+8U14diRGePw7ePyrGvCbyu5N7cf6R/h3gTu7t7/OPFzb7omuI7eUbol8ehbcO8t2nRaN6SYfivjKiomDhHYDw1AP39mavNO6OYJN+d1zcvH7RaPHarADOP7Irr155VFJRRLUZFf8cZq9mDenh6YTlxe2fdY/U6EeXNo0ZNWR/DuvSslIRJQBNG8Q+WPGjbZJ/wOI9jF/dEi1eqbgGskFQD1w38SJeHju/b8zwxRDbozoI71y4kcmC/Chwdapzh4x62Xevinvx+alLoiZ2SVdDP0R3HHOf04/npy2JSfM29ir+qPjXAhbcM5j3bxgYNVJjEFce14M3rhlQ6Ye1ffNYEakbJ3QjqDSfKl57vb1Dc41keuDGm+aybl4dLvAZFmPYYTFDYJWT6rDbfrRtFt9lEpkF7B+TF8adAxqcweD8iPeCAafzWf28Orx9XeI+IX9yRccpqaHiXwtoUDcvaoavTHFkt9Y8c3HshNsH+owjFMEbdpougoaAyCU+vemEmBqLm0Sx7n7umH5xes6mOg9yBHe47hXHxg7t4Gbd1l1xt7s5McDld9oh8V1E9evW4fvRQ6KGbg4iyG2mJKbmt5gpGaFZw7ps9kyH9/O+HX2HZb7nzIN4/euqdZjxG7uoppOodpKo8uWNdJp+80lxh8WOF6UVD/eLNF50Vaocv1873/Q0VFCimDbqJHbtKaNLCkNGKCr+SgBvXjuAkx74JCotqGCZrB86wkO/7MOy9dt5wNU71M/F4WXctQOoI5LQD1xb8A63HU/4wYkE6tqmMUvWRYdUJuM+GXtpP3buTjzvRbMGdWOG+B4VEJ0TdF+ker8kIpVB7pQKVPwVX/wamoMKbKk2sJ11mDOg2KpNO8onpk+GPgE9lWsq7iEI/HC3c1x8dH5Sx7zi2O7c+mb0GPfJRPMc18u/lO6lReN6MeIf5CoSESb+diBNG9blqL98WJ5+SBLuHCXzqM9fSZqgYSLiNR7Hc0PHC0utLK9dld1+Dsny36uOYtih8QdQi9C2aX3uPCO5hs3/86lBecNkq8Kzl8R2OIwXpdWzfbOYuQDSGRmkVB4VfyUQ72Qb3pmXkiHeWP6ZCMkryG/Nraf5j1aZLSb+dmBM2hH5rZMSwf9dfTQTrj+20ufu06kFbeKEeaZKWFxuYUDFXwmmig1zYy44PG6pMOJq8Jt1rCrkWsmyZ/tmHOGaHvPuFMITD+/aKqGvPx5H9fAfv0lRVPyVQNzz/1bG355oaOBmDevx9W0n84bPuENVIRcnaHr2kn7l0wnuV43zDZ8Vp19AZXHXCF+xgxAqNQ8VfyWQgb3aMe7aAYwasj8vXBZ/UhW/8ViSCTtv3aR+WsMLIbnJP6qbJg3q0iaNvvdkSUfHLy/uIbSTDS/1Gz1UyS4q/kpc+nRuyZXH9Ug4zO95R3SJSXPPLVydZNvt4zcsA8BNg/enY8tGHLhPZkv+464dUF46jzfOfmVp1rAef/n5wYyNM9qslzevdabYTDRXgFJ9ZOx1LCJ3AlcAkeEFbzbGTLDbRgGXAaXA9cYY/6mHlBqD3yBr7tmlqpNsD/V89uH+c+Mekd+az6th4pk+nVsy685TE2esAuf1i33Zx2PfvZpx62kHMPTgDokzK9VCputiDxlj7ncniEhvnAnbDwT2ASaJSC9jTOIeJkrO4hdLnmgS70wRz+uz715No2aiygRtavi0kpni8gRDRyjVSzbcPsOAV4wxO40xi4EiIPn6o6IkIN6EM2cmGVuvKLWdTIv/dSLynYg8LSKRWLeOwFJXnmU2LQYRGSEihSJSWFKS3OQUSvbomSMx4NmO9Ex3A7aiZIIq3aUiMklEZvt8hgGPAT2AQ4GVwAOpHt8YM8YYU2CMKWjXLrnu50r2yLboRkg01eT/9U/NX50KC0cP0fHklRpBlXz+xpjg8WpdiMiTwDt2dTngHui7k01TajiSwsQtmSSe9otIeYPwHaf3Zs3mnTz28Q9pO7eW+pWaQsbuVBFxN+ufBURGm3oLGC4iDUSkG9ATmJ4pO5Tqo6aU/CP9AErLTGDj8DkBETuKUlvIZDHlPhGZJSLfAScAvwUwxswBXgXmAu8B12qkT+2ghWvu1Gy6PuKX/CtCQcuMCXxR3H9un0yYpig5Q8ZCPY0xF8TZNhoYnalzK9nhkV/15a1vV3DMvm1p3ig3e3QKQp4d/2FPmUnKUXXpgG4M7NWWi5/5KrPGKUo1kptPqFIjadesAZcdE39+1uogkdunvORfZpLyVf325J4JeziDDmGg1Cy0dUqpdSTS87xynz9JlfyTEX7IzCBqipIptKii1DriRR2JwGXHdGPh6i1cdHRXnv2iODDvezccm9LAaGceph3IlJqDir9S64jX1ixAy8b1efyCwxMeZ/+Uh17OkXAnRUkCdfsotY5E0T5BnFaFQcdO77OPzk2r1Ci05K/UOlIZ0tntIvrX+X25pHg9S9Zt881bfO9pXPvi14yftTJm2z/POyx1QxUli2jJX6l1JIr28SMy5ENBfuvAIZnd3DL0APLbNE75PIqSK6j4K7UOr/S/fd0xCfdp3Ti5YZgb23kLurZpzLE9dbwppeaibh+l1lHHU6RxTypTmVqBm9tO701+2yYMOqA9ny5cW6VjKUo20ZK/Uuvwhnomo/fJBnQ2b1iPa0/Ylzp1hAuP6pq6cYqSI6j4K7UOr9i3a9rAtS31F0MQPdvrfLRKzUXFX6l1eAW+jivwXyPxFcVBxV+pdcQTeG9J/+gebQAYsG/bzBmkKDmINvgqtY54jbreLQX5rSkaPYS6OgmLEjL0jldqHan68VX4lTCid71S60g0jaOiKFWfwP1cEZkjImUiUuDZNkpEikRkgYic6kofbNOKRGRkVc6vKH4kGtVTUZSql/xnAz8HprgTRaQ3MBw4EBgMPCoieSKSB/wLGAL0Bs6zeRUlbajAK0piqtTga4yZB75V6WHAK8aYncBiESkC+tltRcaYRXa/V2zeuVWxQ1GSRd8LiuKQKZ9/R2Cpa32ZTQtKV5S0YeJ0190v5TH6FaV2krDkLyKTgL19Nt1ijBmXfpOizj0CGAHQpUuXTJ5KqUW4x/Lx0q9b62q0RFFyl4Tib4wZVInjLgc6u9Y72TTipPudewwwBqCgoCD5+fSUULPvXk0Ze2k/Lnp6erWcr1f7ptVyHkVJJ5nq5PUW8JKIPAjsA/QEpuO4XHuKSDcc0R8O/CpDNigh5rhe1TPc8uQbj4tb01CUXKVK4i8iZwH/BNoB40VkpjHmVGPMHBF5Fachdw9wrTGm1O5zHfA+kAc8bYyZU6VfoChZpEc7LfUrNZOqRvu8AbwRsG00MNonfQIwoSrnVRRFUaqG9vBVFEUJISr+iqIoIUTFX1EUJYSo+CuKooQQFX9FUZQQouKvKIoSQlT8FUVRQoiKv6IoSghR8VcURQkhKv6KoighRMVfURQlhKj4K4qihBAVf0VRlBCi4q8oihJCVPwVRVFCiIq/oihKCFHxVxRFCSFVEn8ROVdE5ohImYgUuNLzRWS7iMy0n8dd2w4XkVkiUiQiD4uIVMUGRVEUJXWqWvKfDfwcmOKz7QdjzKH2c5Ur/THgCpxJ3XsCg6tog6IoipIiVRJ/Y8w8Y8yCZPOLSAeguTFmmjHGAM8BZ1bFBkVRFCV1Munz7yYi34jIJyJyrE3rCCxz5Vlm03wRkREiUigihSUlJRk0VVEUJVzUTZRBRCYBe/tsusUYMy5gt5VAF2PMOhE5HHhTRA5M1ThjzBhgDEBBQYFJdX9FifDcpf34dKEWIBQlQkLxN8YMSvWgxpidwE67PENEfgB6AcuBTq6snWyaomSUgb3aMbBXu2yboSg5Q0Lxrwwi0g5Yb4wpFZHuOA27i4wx60Vkk4j0B74ELgT+mQkbFOWZi49gx+7SbJuhKDlJlcRfRM7CEe92wHgRmWmMORUYCPxJRHYDZcBVxpj1drdrgGeBRsC79qMoaeeE/ffKtgmKkrOIE3ST+xQUFJjCwsJsm6EoilJjEJEZxpgCv23aw1dRFCWEqPgriqKEEBV/RVGUEKLiryiKEkJU/BVFUUKIir+iKEoIUfFXFEUJITUmzl9ESoAlldy9LbA2jeakC7UrNdSu1FC7UqM22tXVGOM7rkmNEf+qICKFQR0dsonalRpqV2qoXakRNrvU7aMoihJCVPwVRVFCSFjEf0y2DQhA7UoNtSs11K7UCJVdofD5K4qiKNGEpeSvKIqiuFDxVxRFCSG1WvxFZLCILBCRIhEZWQ3ne1pE1ojIbFdaaxGZKCIL7Xcrmy4i8rC17TsR6eva5yKbf6GIXJQGuzqLyEciMldE5ojIb3LBNhFpKCLTReRba9ddNr2biHxpz/8fEalv0xvY9SK7Pd91rFE2fYGInFoVu1zHzBORb0TknVyxS0SKRWSWiMwUkUKblgv3WEsReU1E5ovIPBE5Ktt2ich+9jpFPptE5IZs22WP91t7z88WkZfts1C995cxplZ+gDzgB6A7UB/4Fuid4XMOBPoCs11p9wEj7fJI4K92eSjOLGYC9Ae+tOmtgUX2u5VdblVFuzoAfe1yM+B7oHe2bbPHb2qX6+FM7dkfeBUYbtMfB662y9cAj9vl4cB/7HJv+/82ALrZ/z0vDf/n74CXgHfsetbtAoqBtp60XLjHxgKX2+X6QMtcsMtlXx6wCuiabbuAjsBioJHrvrq4uu+vtIheLn6Ao4D3XeujgFHVcN58osV/AdDBLncAFtjlJ4DzvPmA84AnXOlR+dJk4zjg5FyyDWgMfA0cidObsa73fwTeB46yy3VtPvH+t+58VbCnEzAZOBF4x54nF+wqJlb8s/o/Ai1wxExyyS6PLacAn+eCXTjivxTnZVLX3l+nVvf9VZvdPpELHGGZTatu2htjVtrlVUB7uxxkX0bttlXGw3BK2Vm3zbpWZgJrgIk4pZcNxpg9PucoP7/dvhFokwm7gL8DN+HMQY09Ty7YZYAPRGSGiIywadn+H7sBJcAz1k32lIg0yQG73AwHXrbLWbXLGLMcuB/4EViJc7/MoJrvr9os/jmHcV7PWYutFZGmwP+AG4wxm9zbsmWbMabUGHMoTkm7H7B/ddvgRUR+BqwxxszIti0+HGOM6QsMAa4VkYHujVn6H+viuDsfM8YcBmzFcadk2y4ArO/8DOC/3m3ZsMu2MQzDeWnuAzQBBlenDVC7xX850Nm13smmVTerRaQDgP1eY9OD7MuI3SJSD0f4XzTGvJ5LtgEYYzYAH+FUd1uKSF2fc5Sf325vAazLgF0DgDNEpBh4Bcf1848csCtSasQYswZ4A+eFme3/cRmwzBjzpV1/DedlkG27IgwBvjbGrLbr2bZrELDYGFNijNkNvI5zz1Xr/VWbxf8roKdtQa+PU+17Kwt2vAVEogMuwvG3R9IvtBEG/YGNtir6PnCKiLSyJYRTbFqlEREB/g3MM8Y8mCu2iUg7EWlplxvhtEPMw3kJnBNgV8Tec4APbcntLWC4jYroBvQEplfWLmPMKGNMJ2NMPs5986Ex5vxs2yUiTUSkWWQZ5/rPJsv/ozFmFbBURPazSScBc7Ntl4vzqHD5RM6fTbt+BPqLSGP7bEauV/XeX+loTMnVD07r/fc4fuRbquF8L+P48HbjlIYuw/HNTQYWApOA1javAP+yts0CClzHuRQosp9L0mDXMThV2++AmfYzNNu2AYcA31i7ZgO32/Tu9iYuwqmqN7DpDe16kd3e3XWsW6y9C4AhafxPj6ci2ierdtnzf2s/cyL3dLb/R3u8Q4FC+1++iRMVkwt2NcEpJbdwpeWCXXcB8+19/zxOxE613l86vIOiKEoIqc1uH0VRFCUAFX9FUZQQouKvKIoSQlT8FUVRQoiKv6IoSghR8VcURQkhKv6Koigh5P8Bf219wiB8cEwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# display original example\n", "display_waveform(waveform.numpy()[0,:], title=f\"Original Audio Example (correctly classified as {pred.tolist()[0]})\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We present a final third example. For this example observe that the model correctly classifies it as **8**, but the adversarial example is classified as **3**." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original prediction (ground truth):\t8 (8)\n", "Adversarial prediction:\t\t\t3\n" ] } ], "source": [ "# load a test sample\n", "sample = audiomnist_test[5905]\n", "\n", "waveform = sample['input']\n", "label = sample['digit']\n", "\n", "# craft adversarial example with PGD\n", "epsilon = 0.5\n", "pgd = ProjectedGradientDescent(classifier_art, eps=epsilon)\n", "adv_waveform = pgd.generate(\n", " x=torch.unsqueeze(waveform, 0).numpy()\n", ")\n", "\n", "# evaluate the classifier on the adversarial example\n", "with torch.no_grad():\n", " _, pred = torch.max(model(torch.unsqueeze(waveform, 0)), 1)\n", " _, pred_adv = torch.max(model(torch.from_numpy(adv_waveform)), 1)\n", "\n", "# print results\n", "print(f\"Original prediction (ground truth):\\t{pred.tolist()[0]} ({label})\")\n", "print(f\"Adversarial prediction:\\t\\t\\t{pred_adv.tolist()[0]}\")" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "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": [ "# display adversarial example\n", "display_waveform(adv_waveform[0,0,:], title=f\"Adversarial Audio Example (classified as {pred_adv.tolist()[0]} instead of {pred.tolist()[0]})\")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [ { "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": [ "# display original example\n", "display_waveform(waveform.numpy()[0,:], title=f\"Original Audio Example (correctly classified as {pred.tolist()[0]})\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Apply MP3 compression defense\n", "\n", "Next we are going to apply a simple input preprocessing defense, namely `Mp3Compression`. Ideally, we want this defense to result in correct predictions when applied both to the original and the adversarial audio waveforms." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.28it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.62it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Original prediction with MP3 compression (ground truth):\t8 (8)\n", "Adversarial prediction with MP3 compression:\t\t\t8\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "# initialize Mp3Compression defense\n", "mp3_compression = Mp3Compression(sample_rate=DOWNSAMPLED_SAMPLING_RATE, channels_first=True)\n", "\n", "# apply defense to original input\n", "waveform_mp3 = mp3_compression(torch.unsqueeze(waveform, 0).numpy())[0]\n", "\n", "\n", "# apply defense to adversarial sample\n", "adv_waveform_mp3 = mp3_compression(adv_waveform)[0]\n", "\n", "# evaluate the classifier on the adversarial example\n", "with torch.no_grad():\n", " _, pred_mp3 = torch.max(model(torch.Tensor(waveform_mp3)), 1)\n", " _, pred_adv_mp3 = torch.max(model(torch.Tensor(adv_waveform_mp3)), 1)\n", "\n", "# print results\n", "print(f\"Original prediction with MP3 compression (ground truth):\\t{pred_mp3.tolist()[0]} ({label})\")\n", "print(f\"Adversarial prediction with MP3 compression:\\t\\t\\t{pred_adv_mp3.tolist()[0]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Apply adaptive whitebox attack to defeat MP3 compression defense" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# wrap model and MP3 defense in a ART classifier\n", "classifier_art_def = PyTorchClassifier(\n", " model=model,\n", " loss=torch.nn.CrossEntropyLoss(),\n", " optimizer=None,\n", " input_shape=[1, DOWNSAMPLED_SAMPLING_RATE],\n", " nb_classes=10,\n", " clip_values=(-2**15, 2**15 - 1),\n", " preprocessing_defences=[mp3_compression],\n", ")" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": false }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.22it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.76it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.77it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.85it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.85it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.68it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.80it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.74it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.65it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.42it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.26it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.58it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.26it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.15it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.83it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.60it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.05it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.44it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.43it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.51it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.20it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.48it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.32it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.24it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.41it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.83it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 7.00it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.90it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.59it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.52it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 7.10it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.20it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 5.68it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.32it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.60it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.95it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.64it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.80it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.79it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.59it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.96it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.82it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 7.00it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.98it/s]\n", "MP3 compression: 100%|██████████| 1/1 [00:00<00:00, 6.93it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Original prediction with adaptive classifier (ground truth):\t8 (8)\n", "Adversarial prediction with adaptive classifier:\t\t3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "# craft adversarial example with PGD\n", "epsilon = 0.5\n", "pgd = ProjectedGradientDescent(classifier_art_def, eps=epsilon, eps_step=0.1, max_iter=40)\n", "adv_waveform_def = pgd.generate(\n", " x=torch.unsqueeze(waveform, 0).numpy()\n", ")\n", "\n", "pred_def = np.argmax(classifier_art_def.predict(torch.unsqueeze(waveform, 1).numpy()), axis=1)[0]\n", "pred_adv_def = np.argmax(classifier_art_def.predict(adv_waveform_def), axis=1)[0]\n", "\n", "# print results\n", "print(f\"Original prediction with adaptive classifier (ground truth):\\t{pred_def} ({label})\")\n", "print(f\"Adversarial prediction with adaptive classifier:\\t\\t{pred_adv_def}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "In this notebook we have demonstrated how we can apply the ART library to audio data. By providing a pretrained PyTorch model and loading it via ART's `PyTorchClassifier` we can easily plug in several off the shelf attacks like Projected Gradient Descent.\n", "\n", "Furthermore, we have demonstrated how to apply the `Mp3Compression` defense and demonstrated how to circumvent it with an adaptive whitebox attack.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reproduce CNN\n", "\n", "Our goal is to make it as easy as possible to reproduce or modify our modified AudioMNIST classifier, which we provided as a pretrained fixture in the notebook. Therefore, we provide in the following the original code that we used for training the AudioMNIST classifier.\n", "\n", "**Training script `train.py`**\n", "\n", "```python\n", "#!/usr/bin/env python\n", "\n", "\"\"\"Train a simple AudioNet-like classifier for AudioMNIST.\"\"\"\n", "\n", "import logging\n", "import time\n", "\n", "import torch\n", "\n", "from dataloader import AudioMNISTDataset, PreprocessRaw\n", "from model import RawAudioCNN\n", "\n", "# set global variables\n", "AUDIO_DATA_TRAIN_ROOT = \"data/audiomnist/train\"\n", "AUDIO_DATA_TEST_ROOT = \"data/audiomnist/test\"\n", "\n", "\n", "def _is_cuda_available():\n", " return torch.cuda.is_available()\n", "\n", "\n", "def _get_device():\n", " return torch.device(\"cuda\" if _is_cuda_available() else \"cpu\")\n", "\n", "\n", "def main():\n", " # Step 0: parse args and init logger\n", " logging.basicConfig(level=logging.INFO)\n", "\n", " generator_params = {\n", " 'batch_size': 64,\n", " 'shuffle': True,\n", " 'num_workers': 6\n", " }\n", "\n", " # Step 1: load data set\n", " train_data = AudioMNISTDataset(\n", " root_dir=AUDIO_DATA_TRAIN_ROOT,\n", " transform=PreprocessRaw(),\n", " )\n", " test_data = AudioMNISTDataset(\n", " root_dir=AUDIO_DATA_TEST_ROOT,\n", " transform=PreprocessRaw(),\n", " )\n", "\n", " train_generator = torch.utils.data.DataLoader(\n", " train_data,\n", " **generator_params,\n", " )\n", " test_generator = torch.utils.data.DataLoader(\n", " test_data,\n", " **generator_params,\n", " )\n", "\n", " # Step 2: prepare training\n", " device = _get_device()\n", " logging.info(device)\n", "\n", " model = RawAudioCNN()\n", " if _is_cuda_available():\n", " model.to(device)\n", "\n", " criterion = torch.nn.CrossEntropyLoss()\n", " optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n", "\n", " # Step 3: train\n", " n_epochs = 60\n", " for epoch in range(n_epochs):\n", " # training loss\n", " training_loss = 0.0\n", " # validation loss\n", " validation_loss = 0\n", " # accuracy\n", " correct = 0\n", " total = 0\n", "\n", " model.train()\n", " for batch_idx, batch_data in enumerate(train_generator):\n", " inputs = batch_data['input']\n", " labels = batch_data['digit']\n", " if _is_cuda_available():\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", " # Model computations\n", " optimizer.zero_grad()\n", " # forward + backward + optimize\n", " outputs = model(inputs)\n", " loss = criterion(outputs, labels)\n", " loss.backward()\n", " optimizer.step()\n", " # sum training loss\n", " training_loss += loss.item()\n", " model.eval()\n", " with torch.no_grad():\n", " for batch_idx, batch_data in enumerate(test_generator):\n", " inputs = batch_data['input']\n", " labels = batch_data['digit']\n", " if _is_cuda_available():\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", " outputs = model(inputs)\n", " loss = criterion(outputs, labels)\n", " # sum validation loss\n", " validation_loss += loss.item()\n", " # calculate validation accuracy\n", " predictions = torch.max(outputs.data, 1)[1]\n", " total += labels.size(0)\n", " correct += (predictions == labels).sum().item()\n", "\n", " # calculate final metrics\n", " validation_loss /= len(test_generator)\n", " training_loss /= len(train_generator)\n", " accuracy = 100 * correct / total\n", " logging.info(f\"[{epoch+1}] train-loss: {training_loss:.3f}\"\n", " f\"\\tval-loss: {validation_loss:.3f}\"\n", " f\"\\taccuracy: {accuracy:.2f}\")\n", " logging.info(\"Finished Training\")\n", "\n", " # Step 4: save model\n", " torch.save(\n", " model,\n", " f\"model/model_raw_audio_{time.strftime('%Y%m%d%H%M')}.pt\"\n", " )\n", "\n", "\n", "if __name__ == \"__main__\":\n", " main()\n", "```\n", "\n", "---\n", "\n", "**Dataloader module `dataloader.py`:**\n", "\n", "```python\n", "import glob\n", "import os\n", "\n", "import numpy as np\n", "import torch\n", "import torchaudio\n", "\n", "\n", "OUTPUT_SIZE = 8000\n", "ORIGINAL_SAMPLING_RATE = 48000\n", "DOWNSAMPLED_SAMPLING_RATE = 8000\n", "\n", "\n", "class AudioMNISTDataset(torch.utils.data.Dataset):\n", " \"\"\"Dataset object for the AudioMNIST data set.\"\"\"\n", " def __init__(self, root_dir, transform=None, verbose=False):\n", " self.root_dir = root_dir\n", " self.audio_list = glob.glob(f\"{root_dir}/*/*.wav\")\n", " self.transform = transform\n", " self.verbose = verbose\n", "\n", " def __len__(self):\n", " return len(self.audio_list)\n", "\n", " def __getitem__(self, idx):\n", " audio_fn = self.audio_list[idx]\n", " if self.verbose:\n", " print(f\"Loading audio file {audio_fn}\")\n", " waveform, sample_rate = torchaudio.load_wav(audio_fn)\n", " if self.transform:\n", " waveform = self.transform(waveform)\n", " sample = {\n", " 'input': waveform,\n", " 'digit': int(os.path.basename(audio_fn).split(\"_\")[0])\n", " }\n", " return sample\n", "\n", "\n", "class PreprocessRaw(object):\n", " \"\"\"Transform audio waveform of given shape.\"\"\"\n", " def __init__(self, size_out=OUTPUT_SIZE, orig_freq=ORIGINAL_SAMPLING_RATE,\n", " new_freq=DOWNSAMPLED_SAMPLING_RATE):\n", " self.size_out = size_out\n", " self.orig_freq = orig_freq\n", " self.new_freq = new_freq\n", "\n", " def __call__(self, waveform):\n", " transformed_waveform = _ZeroPadWaveform(self.size_out)(\n", " _ResampleWaveform(self.orig_freq, self.new_freq)(waveform)\n", " )\n", " return transformed_waveform\n", "\n", "\n", "class _ResampleWaveform(object):\n", " \"\"\"Resample signal frequency.\"\"\"\n", " def __init__(self, orig_freq, new_freq):\n", " self.orig_freq = orig_freq\n", " self.new_freq = new_freq\n", "\n", " def __call__(self, waveform):\n", " return self._resample_waveform(waveform)\n", "\n", " def _resample_waveform(self, waveform):\n", " resampled_waveform = torchaudio.transforms.Resample(\n", " orig_freq=self.orig_freq,\n", " new_freq=self.new_freq,\n", " )(waveform)\n", " return resampled_waveform\n", "\n", "\n", "class _ZeroPadWaveform(object):\n", " \"\"\"Apply zero-padding to waveform.\n", "\n", " Return a zero-padded waveform of desired output size. The waveform is\n", " positioned randomly.\n", " \"\"\"\n", " def __init__(self, size_out):\n", " self.size_out = size_out\n", "\n", " def __call__(self, waveform):\n", " return self._zero_pad_waveform(waveform)\n", "\n", " def _zero_pad_waveform(self, waveform):\n", " padding_total = self.size_out - waveform.shape[-1]\n", " padding_left = np.random.randint(padding_total + 1)\n", " padding_right = padding_total - padding_left\n", " padded_waveform = torch.nn.ConstantPad1d(\n", " (padding_left, padding_right),\n", " 0\n", " )(waveform)\n", " return padded_waveform\n", "```\n", "\n", "---\n", "\n", "**Model module `model.py`:**\n", "\n", "```python\n", "import torch.nn as nn\n", "\n", "\n", "class RawAudioCNN(nn.Module):\n", " \"\"\"Adaption of AudioNet (arXiv:1807.03418).\"\"\"\n", " def __init__(self):\n", " super().__init__()\n", " # 1 x 8000\n", " self.conv1 = nn.Sequential(\n", " nn.Conv1d(1, 100, kernel_size=3, stride=1, padding=2),\n", " nn.BatchNorm1d(100),\n", " nn.ReLU(),\n", " nn.MaxPool1d(3, stride=2))\n", " # 32 x 4000\n", " self.conv2 = nn.Sequential(\n", " nn.Conv1d(100, 64, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(64),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 64 x 2000\n", " self.conv3 = nn.Sequential(\n", " nn.Conv1d(64, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 1000\n", " self.conv4 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 500\n", " self.conv5 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 250\n", " self.conv6 = nn.Sequential(\n", " nn.Conv1d(128, 128, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(128),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 128 x 125\n", " self.conv7 = nn.Sequential(\n", " nn.Conv1d(128, 64, kernel_size=3, stride=1, padding=1),\n", " nn.BatchNorm1d(64),\n", " nn.ReLU(),\n", " nn.MaxPool1d(2, stride=2))\n", " # 64 x 62\n", " self.conv8 = nn.Sequential(\n", " nn.Conv1d(64, 32, kernel_size=3, stride=1, padding=0),\n", " nn.BatchNorm1d(32),\n", " nn.ReLU(),\n", " # maybe replace pool with dropout here\n", " nn.MaxPool1d(2, stride=2))\n", "\n", " # 32 x 30\n", " self.fc = nn.Linear(32 * 30, 10)\n", "\n", " def forward(self, x):\n", " x = self.conv1(x)\n", " x = self.conv2(x)\n", " x = self.conv3(x)\n", " x = self.conv4(x)\n", " x = self.conv5(x)\n", " x = self.conv6(x)\n", " x = self.conv7(x)\n", " x = self.conv8(x)\n", " x = x.view(x.shape[0], 32 * 30)\n", " x = self.fc(x)\n", " return x\n", "```\n", "\n", "---" ] } ], "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.8.3" } }, "nbformat": 4, "nbformat_minor": 4 }