lab_music_transfer_learning_sol.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HSqSoFQ7czAK"
   },
   "source": [
    "## Audio Transfer Learning with Scikit-learn and Pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Cq9Yujvbc4UT"
   },
   "source": [
    "We use pre-trained Pytorch models as audio feature extractors, and Scikit-learn classifiers are employed to rapidly prototype competent audio classifiers that can be trained on a CPU.\n",
    "\n",
    "See the pipeline when using the VGGish model:\n",
    "![figure.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XNpWQDnJCd1b"
   },
   "source": [
    "We will use the code within this [repository](https://github.com/LaiaTarres/TransferLearningMusic.git) to help with the implementation of the lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MFZZbnrc_-pQ",
    "outputId": "09bb3e6a-c973-437b-e72e-d7940bd1a21a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cloning into 'TransferLearningMusic'...\n",
      "remote: Enumerating objects: 52, done.\u001b[K\n",
      "remote: Counting objects: 100% (52/52), done.\u001b[K\n",
      "remote: Compressing objects: 100% (51/51), done.\u001b[K\n",
      "remote: Total 52 (delta 17), reused 0 (delta 0), pack-reused 0\u001b[K\n",
      "Unpacking objects: 100% (52/52), done.\n"
     ]
    }
   ],
   "source": [
    "!git clone https://github.com/LaiaTarres/TransferLearningMusic.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B7Ed2cUc_Kqu"
   },
   "source": [
    "Let's change the path so we can work with the code provided by the previously mentioned github."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "60phcCsqAMiB",
    "outputId": "906336b6-cdc2-4848-ee5a-0841053c7339"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/TransferLearningMusic/TransferLearningMusic\n"
     ]
    }
   ],
   "source": [
    "%cd TransferLearningMusic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O35g2hK5dXiR"
   },
   "source": [
    "#Loading the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "skH-vtGUdmX8"
   },
   "source": [
    "As an example, let's download the GTZAN dataset. This dataset can be found in the zip file, which you will have to upload to your google drive preferred location. Approximated download time: between 30 min and an hour. We already provide (fault-filtered) train/test partitions in sklearn-audio-transfer-learning/ data /index /GTZAN/. The dataset contains 10 classes and the scripts you need to run this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X7MCESqpKEC4"
   },
   "source": [
    "The configuration file, where we the paths and hyperparameters are provided"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gBiEC8AQcvuh"
   },
   "outputs": [],
   "source": [
    "DATA_FOLDER = 'data/'\n",
    "config = {\n",
    "    'dataset': 'GTZAN',\n",
    "    'num_classes_dataset': 10,\n",
    "    'audio_folder': DATA_FOLDER + 'audio/GTZAN/genres/',\n",
    "    'audio_paths_train': DATA_FOLDER + 'index/GTZAN/train_filtered.txt',\n",
    "    'audio_paths_test': DATA_FOLDER + 'index/GTZAN/test_filtered.txt',\n",
    "    'pca': False, # resulting number of dimensions to be reduced to (e.g., 128), or False to desactivate it\n",
    "    'model_type': 'SVM', # 'linearSVM', 'SVM', 'perceptron', 'MLP', 'kNN'\n",
    "    'load_training_data': 'training_data_GTZAN_vggish_pytorch.npz', # False or 'training_data_GTZAN_vggish_pytorch.npz', \n",
    "    'load_evaluation_data': 'evaluation_data_GTZAN_vggish_pytorch.npz' # False or 'evaluation_data_GTZAN_vggish.npz'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j_5tQoredZzd"
   },
   "source": [
    "#Preparing the training data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "px7GzUseeMZ0"
   },
   "source": [
    "We will take the vggish model pretrained as feature extractor. You can either extract the training features or load the training data. This las option has been done to save time. That way, loading [X, Y, IDS] takes less time than extracting them.\n",
    "\n",
    "If you are interested in how the feature extraction works, check the extract_features_wrapper function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JD1QLVi2K9oF",
    "outputId": "58f66225-b6b9-4c02-a365-42bba1ea51b9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: soundfile in /usr/local/lib/python3.7/dist-packages (0.10.3.post1)\n",
      "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from soundfile) (1.14.5)\n",
      "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->soundfile) (2.20)\n"
     ]
    }
   ],
   "source": [
    "!pip install soundfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xZsb28wx6HqY",
    "outputId": "8d74da5f-0eff-443a-b916-d8a1f29ebf1a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading training features..\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import src.utils as utils\n",
    "import src.vggish_input as vggish_input\n",
    "import src.vggish_features as vggish_features\n",
    "import torch\n",
    "\n",
    "\n",
    "[paths_train, path2gt_train, path2onehot_train] = utils.load_path2gt(config['audio_paths_train'], config)\n",
    "[paths_test, path2gt_test, path2onehot_test] = utils.load_path2gt(config['audio_paths_test'], config)\n",
    "\n",
    "if config['load_training_data']:\n",
    "        print('Loading training features..')\n",
    "        training_data = np.load(DATA_FOLDER + 'audio_representations/' + config['load_training_data'])\n",
    "        [X, Y, IDS] = [training_data['X'], training_data['Y'], training_data['IDS']]\n",
    "\n",
    "else:\n",
    "        print('Extracting training features..')\n",
    "        #download the database if you haven't done it before, paste the following commands in another cell. Downoad in the folder: sklean-audio-tranfer-learning/data/audio\n",
    "        #!wget http://opihi.cs.uvic.ca/sound/genres.tar.gz\n",
    "        #!tar -zxvf genres.tar.gz\n",
    "        #Model definition\n",
    "        model_pytorch = torch.hub.load('harritaylor/torchvggish', 'vggish', preprocess=False)\n",
    "        model_pytorch.eval()\n",
    "        device_pytorch = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        model_pytorch.to(device_pytorch)\n",
    "        #Extracting the features by passing through the inputs to the model\n",
    "        [X, Y, IDS] = vggish_features.extract_features_wrapper(paths_train, path2gt_train, model = model_pytorch, \n",
    "                                                               configuration = config, device = device_pytorch, \n",
    "                                                               save_as='training_data_{}_{}_pytorch'.format(config['dataset'], 'vggish'), \n",
    "                                                               data_folder=DATA_FOLDER)\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1hxJDuZgdePn"
   },
   "source": [
    "#Build an audio classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q_n8V8HGKvWs"
   },
   "source": [
    "It is time to build the classifier. First, we will chose to do PCA feature reduction as indicated in the configuration file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yMIV3kRYel0g",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "4fed9e09-c535-4b80-edf1-e54bc90e8c32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We don't do PCA. It's ok!\n"
     ]
    }
   ],
   "source": [
    "from sklearn import decomposition\n",
    "if config['pca']: # for dimensionality reduction\n",
    "        pca = decomposition.PCA(n_components=config['pca'], whiten=True)\n",
    "        pca.fit(X)\n",
    "        X = pca.transform(X)\n",
    "        print(\"Shape after PCA: \", X.shape)\n",
    "else:\n",
    "        print(\"We don't do PCA. It's ok!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-rNHwbIROMHA"
   },
   "source": [
    "Then, we will train the classifier chosen in the configuration file with the traning data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hsEty9jFV0Bu",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "b6a4497f-4cc9-4c08-ddd1-b163a0b928de"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting model..\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SVC(C=1, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
       "    decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',\n",
       "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "    tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "def define_classification_model():\n",
    "    \"\"\" Select and define the model you will use for the classifier. \n",
    "    \"\"\"\n",
    "    if config['model_type'] == 'linearSVM': # linearSVM can be faster than SVM\n",
    "        return LinearSVC(C=1)\n",
    "    elif config['model_type'] == 'SVM': # non-linearSVM, we can use the kernel trick\n",
    "        return SVC(C=1, kernel='rbf', gamma='scale')\n",
    "    elif config['model_type'] == 'kNN': # k-nearest neighbour\n",
    "        return KNeighborsClassifier(n_neighbors=1, metric='cosine')\n",
    "    elif config['model_type'] == 'perceptron': # otpimizes log-loss, also known as cross-entropy with sgd\n",
    "        return SGDClassifier(max_iter=600, verbose=0.5, loss='log', learning_rate='optimal')\n",
    "    elif config['model_type'] == 'MLP': # otpimizes log-loss, also known as cross-entropy with sgd\n",
    "        return MLPClassifier(hidden_layer_sizes=(20,), max_iter=600, verbose=10, \n",
    "               solver='sgd', learning_rate='constant', learning_rate_init=0.001)\n",
    "        \n",
    "print('Fitting model..')\n",
    "model = define_classification_model()\n",
    "model.fit(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wiuEUeK1LRA1"
   },
   "source": [
    "Hurray! Now you have the classificator trained and ready to use. Let's evaluate it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pIFq0oivWH3m",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "cda3b71f-2470-44c4-fce6-61a137f2dc9d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating model..\n",
      "Loading evaluation features..\n",
      "Predict labels on evaluation data\n",
      "The model has achieved an accuracy of: 0.7689655172413793\n",
      "The confusion matrix from this experiment: \n",
      "[[13  0  0  0  0 13  0  0  2  3]\n",
      " [ 0 31  0  0  0  0  0  0  0  0]\n",
      " [ 1  0 24  1  0  0  0  2  0  2]\n",
      " [ 0  0  0 24  0  0  0  3  2  0]\n",
      " [ 0  0  0  0 25  0  0  1  0  1]\n",
      " [ 0  2  0  0  0 25  0  0  0  0]\n",
      " [ 0  0  0  1  0  0 24  0  0  2]\n",
      " [ 0  0  0  1  3  0  0 24  0  2]\n",
      " [ 0  0  0  1  5  0  0  2 17  1]\n",
      " [ 2  0  3  2  0  0  4  4  1 16]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import numpy as np\n",
    "\n",
    "print('Evaluating model..')\n",
    "\n",
    "if config['load_evaluation_data']:\n",
    "        print('Loading evaluation features..')\n",
    "        evaluation_data = np.load(DATA_FOLDER + 'audio_representations/' + config['load_evaluation_data'])\n",
    "        [X_eval, IDS_eval] = [evaluation_data['X'], evaluation_data['IDS']]\n",
    "\n",
    "else:\n",
    "        print('Extracting evaluation features..')\n",
    "        [X_eval, Y_eval, IDS_eval] = extract_features_wrapper(paths_test, path2gt_test, model='vggish', \n",
    "                                               save_as='evaluation_data_{}_{}_pytorch'.format(config['dataset'], 'vggish'))\n",
    "\n",
    "if config['pca']: # for dimensionality reduction\n",
    "        X_eval = pca.transform(X_eval)\n",
    "        print(\"Shape after PCA: \", X_eval.shape)\n",
    "\n",
    "print('Predict labels on evaluation data')\n",
    "pred = model.predict(X_eval)\n",
    "\n",
    "y_pred = []\n",
    "y_true = []\n",
    "extension = IDS_eval[0].split('.')[-1] # find original extension\n",
    "for pt in paths_test:\n",
    "        tmp = pt.split('.')\n",
    "        tmp[-1] = extension\n",
    "        pt_extension = '.'.join(tmp) # fix extension\n",
    "        y_pred.append(np.argmax(np.bincount(pred[np.where(IDS_eval==pt_extension)]))) # majority voting\n",
    "        y_true.append(int(path2gt_test[pt]))\n",
    "\n",
    "# print and store the results\n",
    "conf_matrix = confusion_matrix(y_true, y_pred)\n",
    "acc = accuracy_score(y_true, y_pred)\n",
    "print(f'The model has achieved an accuracy of: {acc}')\n",
    "print(f'The confusion matrix from this experiment: \\n{conf_matrix}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QA6-dP9OemRU"
   },
   "source": [
    "Congrats, you have build a music genre classifier! The model we developed (VGGish + 100 PCA + SVM) achieved 77.93% accuracy in our test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vxPByR8GdikP"
   },
   "source": [
    "#Results discussion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Yf3UfZ3Et_p"
   },
   "source": [
    "**1. Which setup gave you the best results? Any hypothesis why?**\n",
    "# TODO:\n",
    "\n",
    "<font color=”green”> YOUR ANSWER </font>\n",
    "\n",
    "---\n",
    "**2. Which setup gave you worst results? Any hypothesis why?**\n",
    "# TODO:\n",
    "\n",
    "<font color=”green”> YOUR ANSWER </font>\n",
    "\n",
    "---\n",
    "**3. Why do we get different results when running several times the same neural network-based experiment?**\n",
    "# TODO:\n",
    "\n",
    "<font color=”green”> YOUR ANSWER </font>"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "AIDL_05_lab_music_transfer_learning.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "toc_visible": true
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}