Code_part_by_part_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f9317204",
   "metadata": {},
   "source": [
    "# TTK4275 Music Classification Project\n",
    "\n",
    "## Code: part-by-part\n",
    "\n",
    "This notebook contains the majority of the relevant code. For the code that finds the optimal hyperparameters in part 4, please refer to the attached code folder. This notebook has to be run from top to buttom, in that order, to guarantee the right result in each cell. E.g. if you only want to look at part 4, you have to run the previously parts first. This can easily be done from the *cell* or *run* dropdown menu in the menu bar on top. \n",
    "\n",
    "Tip: Do *Cell -> Run all* or *Run -> Run all cells* in the beggining to have all code run before reading.  \n",
    "\n",
    "### Part 0: Imports and initialising of features\n",
    "\n",
    "First we need to initialise a feature structure and load the feature data into it. \n",
    "First some necessary imports: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "564cea4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from itertools import combinations\n",
    "import copy\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.mixture import GaussianMixture\n",
    "from sklearn.neural_network import MLPClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "790ddc27",
   "metadata": {},
   "source": [
    "Then we need to define a SongFeature stuct and define some reading function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c3e970b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SongFeatures:\n",
    "    def __init__(self, arr):\n",
    "        self.Track_ID,self.File,self.zero_cross_rate_mean,self.zero_cross_rate_std,self.rmse_mean,self.rmse_var,self.spectral_centroid_mean,self.spectral_centroid_var,\\\n",
    "        self.spectral_bandwidth_mean,self.spectral_bandwidth_var,self.spectral_rolloff_mean,self.spectral_rolloff_var,self.spectral_contrast_mean,self.spectral_contrast_var,self.spectral_flatness_mean,\\\n",
    "        self.spectral_flatness_var,self.chroma_stft_1_mean,self.chroma_stft_2_mean,self.chroma_stft_3_mean,self.chroma_stft_4_mean,self.chroma_stft_5_mean,self.chroma_stft_6_mean,self.chroma_stft_7_mean,\\\n",
    "        self.chroma_stft_8_mean,self.chroma_stft_9_mean,self.chroma_stft_10_mean,self.chroma_stft_11_mean,self.chroma_stft_12_mean,self.chroma_stft_1_std,self.chroma_stft_2_std,self.chroma_stft_3_std,\\\n",
    "        self.chroma_stft_4_std,self.chroma_stft_5_std,self.chroma_stft_6_std,self.chroma_stft_7_std,self.chroma_stft_8_std,self.chroma_stft_9_std,self.chroma_stft_10_std,self.chroma_stft_11_std,self.chroma_stft_12_std,\\\n",
    "        self.tempo,self.mfcc_1_mean,self.mfcc_2_mean,self.mfcc_3_mean,self.mfcc_4_mean,self.mfcc_5_mean,self.mfcc_6_mean,self.mfcc_7_mean,self.mfcc_8_mean,self.mfcc_9_mean,self.mfcc_10_mean,self.mfcc_11_mean,\\\n",
    "        self.mfcc_12_mean,self.mfcc_1_std,self.mfcc_2_std,self.mfcc_3_std,self.mfcc_4_std,self.mfcc_5_std,self.mfcc_6_std,self.mfcc_7_std,self.mfcc_8_std,self.mfcc_9_std,self.mfcc_10_std,self.mfcc_11_std,self.mfcc_12_std,\\\n",
    "        self.GenreID,self.Genre,self.Type = arr\n",
    "        \n",
    "def readGenreClassData(file_path):\n",
    "    '''\n",
    "    Read genre class data from path_to_file and returns a dict of SongFeatures [from TrackID to SongFeature]\n",
    "    '''\n",
    "    with open(file_path) as f:\n",
    "        f.readline() #Remove description\n",
    "        lines = f.readlines()\n",
    "    dict_of_SF = dict()\n",
    "    for str in lines:\n",
    "        arr = re.split(r'\\t+', str.rstrip('\\n'))\n",
    "        arr[0] = int(arr[0])\n",
    "        arr[-3] = int(arr[-3])\n",
    "        for i in range(2,len(arr)-3):\n",
    "            arr[i] = float(arr[i])\n",
    "        dict_of_SF[arr[0]] = SongFeatures(arr)\n",
    "    return dict_of_SF\n",
    "\n",
    "def getPointsAndClasses(songs_dict, features, classes, type):\n",
    "    '''\n",
    "    input:  songs_dict  - a dict from id to SongFeature\n",
    "            features    - array of features to be used\n",
    "            classes     - array of classes to be used\n",
    "            type        - \"Train\" or \"Test\"\n",
    "    output: X, y, id_list - X is a np.array of size (N_POINTS, N_FEATURES), \n",
    "                            y is a np.array of class ids with size N_POINTS, \n",
    "                            id_list is id to corresponding song\n",
    "    '''\n",
    "    n_features  = len(features)\n",
    "\n",
    "    X = np.empty([0,n_features])\n",
    "    y = np.empty(0,dtype=np.int16)\n",
    "    id_list = []\n",
    "    for song in songs_dict.values():\n",
    "        if song.Type == type and song.Genre in classes:\n",
    "            x = np.zeros([1,n_features])\n",
    "            for i in range(n_features):\n",
    "                x[0,i] = song.__dict__[features[i]]\n",
    "            X = np.append(X,x,axis = 0)\n",
    "            y = np.append(y,song.GenreID) \n",
    "            id_list.append(song.Track_ID)\n",
    "    \n",
    "    return X, y, id_list\n",
    "\n",
    "def genre_string_to_id(genre):\n",
    "    '''\n",
    "    input: genre in string format\n",
    "    output: genre id\n",
    "    '''\n",
    "    genres = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]\n",
    "    return genres.index(genre)\n",
    "\n",
    "def genre_id_to_string(genre_id):\n",
    "    '''\n",
    "    input: genre_id\n",
    "    output: genre in string format\n",
    "    '''\n",
    "    genres = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]\n",
    "    return genres[genre_id]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d07d1c80",
   "metadata": {},
   "source": [
    "Next step is to actually read from file: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "676da571",
   "metadata": {},
   "outputs": [],
   "source": [
    "songs_dict = readGenreClassData(\"Data/GenreClassData_30s.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa6d2a2f",
   "metadata": {},
   "source": [
    "### Part 1: Design of KNN classifier\n",
    "\n",
    "This notebook only contains our own KNN classifier. The sklearn implementation can be found in the attached code folder. \n",
    "\n",
    "First we designed a KNN classifier class: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "74aac12a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class KNNClassifier:\n",
    "    def __init__(self, X, y, ids_list, features, k, input_normalisation_type = \"\"):\n",
    "        '''\n",
    "        X               : point nd.array of dimension (N_POINTS, N_FEATURES)\n",
    "        y               : nd.array of class labels\n",
    "        ids_list        : array of correspongin track ids \n",
    "        features        : array of feature strings\n",
    "        k               : int \n",
    "        should_normalise: \"\" -> no normalisation, \"z_score\", \"min_max\"\n",
    "        '''\n",
    "        self.X = X.copy()\n",
    "        self.y = y.copy()\n",
    "        self.ids_list = ids_list.copy()\n",
    "        self.classes_id = list(np.unique(y))\n",
    "        self.classes = [genre_id_to_string(i) for i in self.classes_id]\n",
    "        self.num_classes = len(self.classes)\n",
    "        self.k = k\n",
    "        self.features = features\n",
    "        self.dim = len(features)\n",
    "        self.num_points = np.size(X,0)\n",
    "        \n",
    "        #PCA variables:\n",
    "        self.isPCAused = False\n",
    "        self.pca_n_components = 0\n",
    "        \n",
    "        #Normalisation\n",
    "        # Keep track of mean, sd, min and max for each feature to normalise\n",
    "        self.features_mean_sd = [] # array of tuple (mean, sd)\n",
    "        self.features_min_max = [] # array of tuple (min, max)\n",
    "        \n",
    "        self.input_normalisation_type = input_normalisation_type\n",
    "        if input_normalisation_type == \"z_score\":\n",
    "            self.z_score_normalise()\n",
    "        elif input_normalisation_type == \"min_max\":\n",
    "            self.min_max_normalise()\n",
    "            \n",
    "    def z_score_normalise(self):\n",
    "        '''\n",
    "        Normalises features using z-score normalisation\n",
    "        '''\n",
    "        for i in range(self.dim):\n",
    "            mean = np.mean(self.X[:,i])\n",
    "            var = np.var(self.X[:,i])\n",
    "            sd = np.sqrt(var)\n",
    "            self.X[:,i] = (self.X[:,i]-mean)/sd\n",
    "            self.features_mean_sd.append((mean,sd))\n",
    "\n",
    "    def min_max_normalise(self):\n",
    "        '''\n",
    "        Normalises features using min-max normalisation\n",
    "        '''\n",
    "        for i in range(self.dim):\n",
    "            min = np.min(self.X[:,i])\n",
    "            max = np.max(self.X[:,i])\n",
    "            diff = max - min\n",
    "\n",
    "            self.X[:,i] = (self.X[:,i]-min)/diff\n",
    "            self.features_min_max.append((min,max))\n",
    "        \n",
    "    def doPCA(self, n_components):\n",
    "        '''\n",
    "        Transform points using PCA analysis\n",
    "        Changes self.points\n",
    "        '''\n",
    "        self.isPCAused = True\n",
    "        self.pca_n_components = n_components\n",
    "\n",
    "        self.pca = PCA(n_components=n_components)\n",
    "        self.X = self.pca.fit_transform(self.X)\n",
    "\n",
    "    def classify(self, x):\n",
    "        '''\n",
    "        input: x of type np.array with dim = k (NOT normalised)\n",
    "        output: genre ID\n",
    "        '''\n",
    "        #normalise input if normalisation is enabled\n",
    "        if self.input_normalisation_type == \"z_score\":\n",
    "            for i in range(self.dim):\n",
    "                x[i] = (x[i]-self.features_mean_sd[i][0])/self.features_mean_sd[i][1]\n",
    "        elif self.input_normalisation_type == \"min_max\":\n",
    "            for i in range(self.dim):\n",
    "                min = (self.features_min_max[i][0])\n",
    "                max = self.features_min_max[i][1]\n",
    "                diff = max-min\n",
    "                x[i] = (x[i]-min)/diff\n",
    "        \n",
    "        #Do PCA transform if PCA is anabled\n",
    "        if self.isPCAused:\n",
    "            x = self.pca.transform(x.reshape(1, -1))\n",
    "\n",
    "        # Calculate distances\n",
    "        difference = self.X-x\n",
    "        distances = np.sum(difference*difference,axis=1)\n",
    "        # k smallest distances: \n",
    "        #function gives array of indexes\n",
    "        index_k_nearest_points = np.argpartition(distances, self.k)[:self.k] \n",
    "        distance_k_nearest_points = distances[index_k_nearest_points]\n",
    "\n",
    "        # Find genres \n",
    "        genres_k_nearest_points = []\n",
    "        for i in index_k_nearest_points:\n",
    "            genres_k_nearest_points.append(self.y[i])\n",
    "        \n",
    "        # Combine data [[index, distance,genre], [index,distance,genre], ...]\n",
    "        k_nearest_points = [[index_k_nearest_points[i],distance_k_nearest_points[i],\n",
    "                            genres_k_nearest_points[i]] for i in range(self.k)]\n",
    "        \n",
    "        #Count genres\n",
    "        genres_count = dict()\n",
    "        for point in k_nearest_points:\n",
    "            genres_count[point[2]] = genres_count.get(point[2],0) + 1\n",
    "        genres_count = list(genres_count.items())\n",
    "        genres_count = sorted(genres_count, key=lambda tup: tup[1], reverse=True)\n",
    "\n",
    "        #Find genre(s) with most entries, delete the others\n",
    "        for i in range(1,len(genres_count)):\n",
    "            if genres_count[i][1] < genres_count[i-1][1]:\n",
    "                genres_count = genres_count[:i]\n",
    "                break\n",
    "        \n",
    "        genres = [genre[0] for genre in genres_count]\n",
    "\n",
    "        #Find all points belonging to these genres\n",
    "        points_to_consider = []\n",
    "        for point in k_nearest_points:\n",
    "            if point[2] in genres:\n",
    "                points_to_consider.append(point)\n",
    "\n",
    "        #Sort points to consider\n",
    "        points_to_consider = sorted(points_to_consider, key=lambda x:x[1])\n",
    "\n",
    "        #Return genre ID with smallest distance\n",
    "        return points_to_consider[0][2]\n",
    "    \n",
    "    def evaluate(self, X_test, y_test, ids_list_test):\n",
    "        '''\n",
    "        input: \n",
    "        X_test                  : point nd.array of dimension (N_POINTS, N_FEATURES)\n",
    "        y_test                  : nd.array of class labels\n",
    "        ids_list_test           : array of correspongin track ids \n",
    "\n",
    "        output:\n",
    "        confusion_matrix        : 2D np array of ints with size (N_CLASSES, N_CLASSES)\n",
    "        confusion_matrix_list   : 2D array containg lists of classified song ids\n",
    "        er                      : Error rate          \n",
    "        '''\n",
    "        confusion_matrix_list = [[[] for j in range(self.num_classes)] for i in range(self.num_classes)]\n",
    "        confusion_matrix = np.zeros([self.num_classes,self.num_classes])\n",
    "\n",
    "        for i in range(len(y_test)):\n",
    "            genre_id = y_test[i]\n",
    "            classified_id = self.classify(X_test[i,:])\n",
    "            correct_index = self.classes_id.index(genre_id)\n",
    "            predicted_index = self.classes_id.index(classified_id)\n",
    "            confusion_matrix_list[correct_index][predicted_index].append(ids_list_test[i])\n",
    "            confusion_matrix[correct_index][predicted_index] +=  1\n",
    "        er = error_rate(confusion_matrix)\n",
    "        return confusion_matrix, confusion_matrix_list, er"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f32184dd",
   "metadata": {},
   "source": [
    "As well as defining an error rate function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5d91dc9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def error_rate(confusion_matrix):\n",
    "    '''\n",
    "    input: confusion matrix as a 2D array\n",
    "    output: error rate (# of falsely classified points)/( # total points)\n",
    "    '''\n",
    "    total = np.sum(confusion_matrix)\n",
    "    correct = np.sum(np.diagonal(confusion_matrix))\n",
    "    \n",
    "    error_rate = (total-correct)/total\n",
    "\n",
    "    return error_rate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c44ad5d",
   "metadata": {},
   "source": [
    "Next we define features and genres we want to use, and extract the training and test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "61f74224",
   "metadata": {},
   "outputs": [],
   "source": [
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\",\"mfcc_1_mean\",\"tempo\"]\n",
    "genres      = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0da9b462",
   "metadata": {},
   "source": [
    "Then create a KNN classifier with the training set and evaluate on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "01c943e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error rate of KNN without normalisation is:  0.6262626262626263\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate of KNN without normalisation is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdea88c7",
   "metadata": {},
   "source": [
    "With z score normalisation: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d950bbf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error rate of KNN with z-score normalisation is:  0.601010101010101\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"z_score\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate of KNN with z-score normalisation is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c719c9",
   "metadata": {},
   "source": [
    "With min-max normalisation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bc3646be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error rate of KNN with min-max is:  0.5858585858585859\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate of KNN with min-max is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3717bc87",
   "metadata": {},
   "source": [
    "### Part 2: Separability\n",
    "\n",
    "Here we only look at 4 genres in this part, so we have to redefine some variables: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c09eac7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\",\"mfcc_1_mean\",\"tempo\"]\n",
    "genres      = [\"pop\", \"disco\",\"metal\",\"classical\"] \n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f424d43d",
   "metadata": {},
   "source": [
    "Implement a histogram plotter: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fbefb243",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_histogram(X , y, features, mode = \"separat\"):\n",
    "    '''\n",
    "    input: \n",
    "    X       : Points np.array() with size (N_POINTS,N_FEATURES)\n",
    "    y       : Class IDs np.array() with size (N_POINTS)\n",
    "    features: array of features\n",
    "    mode    : \"separat\" or \"overlayed\"\n",
    "\n",
    "    output:axs_list\n",
    "    '''\n",
    "    # Define parameters:\n",
    "    n_bins = 14\n",
    "    n_features = len(features)\n",
    "    n_points = np.size(X,0)\n",
    "    # Get max and min for each feature\n",
    "    min_max_features = [] # Array with tuple for min and max for each feature\n",
    "    for i in range(n_features):\n",
    "        mm = [0,0]\n",
    "        mm[0] = np.min(X[:,i])\n",
    "        mm[1] = np.max(X[:,i])\n",
    "        min_max_features.append(mm)\n",
    "    \n",
    "    # Extract genres from dataset: \n",
    "    genre_dict = dict() # Dict from genre ID to np.array of points\n",
    "    for i in range(n_points):\n",
    "        genre_id = y[i]\n",
    "        genre_dict[genre_id] = np.append(genre_dict.get(genre_id, np.empty([0,n_features])), X[i,:].reshape(1,n_features), axis=0)\n",
    "\n",
    "    n_genres = len(genre_dict)\n",
    "\n",
    "    axs_list = [None]*n_features\n",
    "    if mode == \"separat\":\n",
    "        for j in range(n_features):\n",
    "            fig, axs = plt.subplots(n_genres,1,sharey=True, tight_layout=True)\n",
    "            plt.setp(axs, xlim=(min_max_features[j][0],min_max_features[j][1]), ylim=(0,20))\n",
    "            i = 0\n",
    "            for genre_id in genre_dict:\n",
    "                axs[i].hist(genre_dict[genre_id][:,j], bins = n_bins)\n",
    "                axs[i].set_title(genre_id_to_string(genre_id))\n",
    "                i = i + 1\n",
    "            fig.suptitle(features[j])\n",
    "            axs_list[j] = axs\n",
    "        \n",
    "\n",
    "\n",
    "    elif mode == \"overlayed\":\n",
    "        colors = [  (1,0,0,0.5),(0,1,0,0.5),(0,0,1,0.5),(1,1,0,0.5),(1,0,1,0.5),(0,1,1,0.5),\n",
    "                    (0.95,0.5,0.2,0.5), (0.25,0.75,0.3,0.5),(0.5,0,0,0.5),(0.25,0.4,0.8,0.5)]\n",
    "        for j in range(n_features):\n",
    "            fig, axs = plt.subplots(1,1,sharey=True, tight_layout=True)\n",
    "            plt.setp(axs, xlim=(min_max_features[j][0],min_max_features[j][1]), ylim=(0,20))\n",
    "            i = 0\n",
    "            for genre_id in genre_dict:\n",
    "                axs.hist(genre_dict[genre_id][:,j], bins = n_bins, label = genre_id_to_string(genre_id), fc = colors[i])\n",
    "                i = i + 1\n",
    "            fig.suptitle(features[j])\n",
    "            axs_list[j] = axs\n",
    "\n",
    "            #Add legends\n",
    "            axs.legend(loc='best', frameon=False)\n",
    "            fig.suptitle(features[j])\n",
    "\n",
    "    return axs_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19ca834d",
   "metadata": {},
   "source": [
    "Plot the histograms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "89d53960",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\",\"mfcc_1_mean\",\"tempo\"]\n",
    "axs_list = plot_histogram(X_train, y_train, features, mode = \"overlayed\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "782bfa47",
   "metadata": {},
   "source": [
    "Create a KNN classifier for each feature selection and evaluate: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "df649715",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chosen features:  ['spectral_rolloff_mean', 'spectral_centroid_mean', 'mfcc_1_mean', 'tempo']\n",
      "The error rate is:  0.3037974683544304\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chosen features:  ['spectral_rolloff_mean', 'spectral_centroid_mean', 'mfcc_1_mean']\n",
      "The error rate is:  0.25316455696202533\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chosen features:  ['spectral_rolloff_mean', 'spectral_centroid_mean']\n",
      "The error rate is:  0.27848101265822783\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chosen features:  ['spectral_rolloff_mean']\n",
      "The error rate is:  0.3924050632911392\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\",\"mfcc_1_mean\",\"tempo\"]\n",
    "print(\"Chosen features: \", features)\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()\n",
    "\n",
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\",\"mfcc_1_mean\"]\n",
    "print(\"Chosen features: \", features)\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()\n",
    "\n",
    "features    = [\"spectral_rolloff_mean\",\"spectral_centroid_mean\"]\n",
    "print(\"Chosen features: \", features)\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()\n",
    "\n",
    "features    = [\"spectral_rolloff_mean\"]\n",
    "print(\"Chosen features: \", features)\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e5b7dea",
   "metadata": {},
   "source": [
    "*Extra task: separability with PCA*\n",
    "\n",
    "We also wanted to see how separat the four genres can become with three features. For that we used principal component analysis. \n",
    "\n",
    "First we had to create a 3D plotter function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c878d652",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_3D_feature_space(X , y, features):\n",
    "        '''\n",
    "        input\n",
    "        training_set: a GenreSet\n",
    "        genres: list of genres to plot\n",
    "        features: a list of size 3 with features to use\n",
    "\n",
    "        output\n",
    "        returns an ac object if dim==3, else nothing\n",
    "        '''\n",
    "        if (np.size(X,1) != 3):\n",
    "            return\n",
    "\n",
    "        # Define parameters:\n",
    "        n_features = len(features)\n",
    "        n_points = np.size(X,0)\n",
    "        # Get max and min for each feature\n",
    "        min_max_features = [] # Array with tuple for min and max for each feature\n",
    "        for i in range(n_features):\n",
    "            mm = [0,0]\n",
    "            mm[0] = np.min(X[:,i])\n",
    "            mm[1] = np.max(X[:,i])\n",
    "            min_max_features.append(mm)\n",
    "        \n",
    "        # Extract genres from dataset: \n",
    "        genre_dict = dict() # Dict from genre ID to np.array of points\n",
    "        for i in range(n_points):\n",
    "            genre_id = y[i]\n",
    "            genre_dict[genre_id] = np.append(genre_dict.get(genre_id, np.empty([0,n_features])), X[i,:].reshape(1,n_features), axis=0)\n",
    "        \n",
    "        #Init figure\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(projection='3d')\n",
    "\n",
    "        for genre in genre_dict:\n",
    "            ax.scatter(genre_dict[genre][:,0],genre_dict[genre][:,1],genre_dict[genre][:,2],label=genre_id_to_string(genre))\n",
    "\n",
    "        #Set labels\n",
    "        ax.set_xlabel(features[0])\n",
    "        ax.set_ylabel(features[1])\n",
    "        ax.set_zlabel(features[2])\n",
    "\n",
    "        #Add legends\n",
    "        ax.legend(loc='best', frameon=False)\n",
    "\n",
    "        return ax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "140bea30",
   "metadata": {},
   "source": [
    "Then we had to do the PC anlysis, plot the 3D feature space and evaluate the confusion matrix with PCA: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cfeea6ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error rate is:  0.13924050632911392\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "features    = [ \"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "                \"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "                \"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "                \"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "                \"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "                \"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "                \"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "                \"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "scaler = MinMaxScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "\n",
    "pca = PCA(n_components=3)\n",
    "X_train = pca.fit_transform(X_train)\n",
    "\n",
    "ax = plot_3D_feature_space(X_train,y_train,[\"PC1\", \"PC2\", \"PC3\"])\n",
    "plt.show()\n",
    "\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "knn = KNNClassifier(X_train, y_train, ids_train, features, 5 ,\"min_max\")\n",
    "knn.doPCA(3)\n",
    "cm, cm_list, er = knn.evaluate(X_test.copy(),y_test.copy(),ids_test.copy()) \n",
    "print(\"The error rate is: \", er)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "268cfb31",
   "metadata": {},
   "source": [
    "### Part 3: Feature selection\n",
    "\n",
    "We implemented two feature selection methods: one iterative solution using k-fold cross validation and one using the ANOVA f-value as metric for best features. \n",
    "\n",
    "#### K-fold Cross Validation\n",
    "\n",
    "We work again on all genres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c8c5d336",
   "metadata": {},
   "outputs": [],
   "source": [
    "genres      = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55d44e5",
   "metadata": {},
   "source": [
    "Define feature pools and make all combinations of pool 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1605bedc",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_pool_1 = [\"spectral_centroid_mean\",\"mfcc_1_mean\",\"spectral_rolloff_mean\",\"tempo\"]\n",
    "feature_pool_2 = [\"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "\"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "\"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "\"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "\"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "\"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "\"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "\"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "feature_pool_1_combinations = list(combinations(feature_pool_1,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13a7c0c4",
   "metadata": {},
   "source": [
    "Define an iterative function that checks all possible feature combinations, calculate average errors on folds and returns the best function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "204552ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_fold_cross_validation(feature_pool_1_combinations, feature_pool_2):\n",
    "    best_error_rate = 1\n",
    "    chosen_features = []\n",
    "    \n",
    "    n_splits = 4\n",
    "\n",
    "    for comb in feature_pool_1_combinations:\n",
    "        for feature in feature_pool_2:\n",
    "            features = list(comb) + [feature]\n",
    "            X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "            scaler = MinMaxScaler()\n",
    "            X_train = scaler.fit_transform(X_train)\n",
    "            skf = StratifiedKFold(n_splits=n_splits)\n",
    "            skf.get_n_splits(X_train, y_train)\n",
    "            errors = np.zeros(n_splits)\n",
    "            ei = 0\n",
    "            for train_index, test_index in skf.split(X_train, y_train):\n",
    "                knn = KNNClassifier(X_train[train_index,:], y_train[train_index], np.array(ids_train)[train_index], features, 5 ,\"min_max\")\n",
    "                cm, cm_list, er = knn.evaluate(X_train[test_index,:].copy(), y_train[test_index].copy(), np.array(ids_train)[test_index].copy())\n",
    "                errors[ei] = er\n",
    "                ei = ei + 1\n",
    "\n",
    "            avg_error = np.average(errors)\n",
    "            if avg_error < best_error_rate:\n",
    "                best_error_rate = avg_error\n",
    "                chosen_features = features\n",
    "    return chosen_features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d21eef",
   "metadata": {},
   "source": [
    "Run the function:\n",
    "\n",
    "**NB - Can take some time**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "81a41214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected features: \n",
      "['spectral_centroid_mean', 'mfcc_1_mean', 'spectral_rolloff_mean', 'rmse_var']\n"
     ]
    }
   ],
   "source": [
    "chosen_features = k_fold_cross_validation(feature_pool_1_combinations, feature_pool_2)\n",
    "print(\"Selected features: \")\n",
    "print(chosen_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcc08c08",
   "metadata": {},
   "source": [
    "Evaluate performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1d03a7a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error rate:  0.4898989898989899\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,chosen_features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,chosen_features, genres, \"Test\")\n",
    "\n",
    "knn = KNNClassifier(X_train, y_train, ids_train,chosen_features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test, y_test, np.array(ids_test).copy())\n",
    "\n",
    "print(\"Error rate: \", er)\n",
    "\n",
    "# Plot confusion matrices\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84055325",
   "metadata": {},
   "source": [
    "#### ANOVA f value feature selection\n",
    "\n",
    "Initialise variables and calculate scores for each feature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1927a9ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_pool_2 = [\"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "\"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "\"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "\"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "\"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "\"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "\"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "\"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "\n",
    "# Get points and classes\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,feature_pool_2, genres, \"Train\")\n",
    "\n",
    "# Define k_best object\n",
    "k_best = SelectKBest(k=\"all\")\n",
    "k_best = k_best.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b76bd3e",
   "metadata": {},
   "source": [
    "Find the best features that uses at least 3 from the given features: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9ec2a586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chosen featues:  ['mfcc_1_mean', 'spectral_bandwidth_mean', 'spectral_rolloff_mean', 'spectral_centroid_mean']\n"
     ]
    }
   ],
   "source": [
    "# Get scores for each feature and index\n",
    "scores = np.array(k_best.scores_)\n",
    "scores_and_index = [(i, scores[i]) for i in range(len(scores))]\n",
    "scores_and_index = sorted(scores_and_index, key=lambda tup: tup[1], reverse=True)\n",
    "\n",
    "# Find best features\n",
    "chosen_features = []\n",
    "joker_taken = False\n",
    "\n",
    "for si in scores_and_index:\n",
    "    idx = si[0]\n",
    "    feature = feature_pool_2[idx]\n",
    "\n",
    "    if feature in feature_pool_1:\n",
    "        chosen_features.append(feature)\n",
    "    elif joker_taken is False: \n",
    "        chosen_features.append(feature)\n",
    "        joker_taken = True\n",
    "\n",
    "    if len(chosen_features) == 4:\n",
    "        break\n",
    "\n",
    "print(\"Chosen featues: \", chosen_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9824d296",
   "metadata": {},
   "source": [
    "Evaluate performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0aa03172",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error rate:  0.5656565656565656\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,chosen_features, genres, \"Train\")\n",
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,chosen_features, genres, \"Test\")\n",
    "\n",
    "knn = KNNClassifier(X_train, y_train, ids_train,chosen_features, 5 ,\"min_max\")\n",
    "cm, cm_list, er = knn.evaluate(X_test, y_test, np.array(ids_test).copy())\n",
    "\n",
    "print(\"Error rate: \", er)\n",
    "\n",
    "# Plot confusion matrices\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=knn.classes)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4682403",
   "metadata": {},
   "source": [
    "### Part 4: A general classifier\n",
    "\n",
    "Two methods were implemented: maximum log-likelihood of Gaussian mixture models of the data, using feature selection, and a multi layered perceptron, using all features. \n",
    "\n",
    "#### Gaussian mixture model classifier\n",
    "The training to find the best GM takes some time, so this will not be implemented here. This is implemented in task4_GM_trainer.py in the scripts folder. Here we will implement the evaluation of the final GM, when the number of components and number of best features to use have been found.\n",
    "\n",
    "Again we first initialise features, genres and data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3979b673",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose features and genres:\n",
    "features    = [ \"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "                \"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "                \"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "                \"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "                \"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "                \"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "                \"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "                \"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "genres          = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]\n",
    "\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de670c98",
   "metadata": {},
   "source": [
    "Normalise and find k best features, where k = 14 has been found from training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "20582f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create scalers and kbest transform\n",
    "scaler  = MinMaxScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "k_best  = SelectKBest(k=14)\n",
    "X_train = k_best.fit_transform(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379c0153",
   "metadata": {},
   "source": [
    "Define component size of models and create models:\n",
    "\n",
    "*Most likely a warning will pop up, ignore this.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "eb01be4b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\finng\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:881: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n",
      "C:\\Users\\finng\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:881: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n",
      "C:\\Users\\finng\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:881: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n",
      "C:\\Users\\finng\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:881: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n",
      "C:\\Users\\finng\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:881: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "model_sizes = {'pop': 1, 'metal': 1, 'disco': 8, 'blues':2, 'reggae':1, 'classical':1, 'rock': 4, 'hiphop': 6, 'country': 1, 'jazz':3}\n",
    "\n",
    "# Init dict for best models for each genre\n",
    "best_gmms = dict() # Dict from genre to best gmm for that genre\n",
    "\n",
    "# Create appropriate model\n",
    "for genre in genres:\n",
    "    # Here we fit a GM\n",
    "    X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, [genre], \"Train\")\n",
    "    X_train = scaler.transform(X_train)\n",
    "    X_train = k_best.transform(X_train)\n",
    "    gmm = GaussianMixture(n_components=model_sizes[genre], covariance_type=\"full\",init_params='kmeans',random_state=1)\n",
    "    gmm.fit(X_train)\n",
    "    best_gmms[genre] = copy.deepcopy(gmm)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b5e211",
   "metadata": {},
   "source": [
    "Evaluate model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "893e82d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error rate:  0.4595959595959596\n"
     ]
    }
   ],
   "source": [
    "# Get test set\n",
    "X_test, y_test, ids  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "# Scale and extract k best features\n",
    "X_test = scaler.transform(X_test)\n",
    "X_test = k_best.transform(X_test)\n",
    "\n",
    "# Compute log likelihood for every function\n",
    "log_likelihood = np.zeros((len(y_test),len(genres)))\n",
    "for genre, model in best_gmms.items():\n",
    "    log_likelihood[:,genres.index(genre)]  = model.score_samples(X_test)\n",
    "\n",
    "# Find index of best log likelihood\n",
    "maxVal_ind_rowise = np.argmax(log_likelihood, axis=1)\n",
    "\n",
    "# Create confusion matrix\n",
    "cm = np.zeros((len(genres), len(genres)))\n",
    "for i in range(len(y_test)):\n",
    "    cm[genres.index(genre_id_to_string(y_test[i])), maxVal_ind_rowise[i]] += 1\n",
    "\n",
    "# Display confusion matrices\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=genres)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()\n",
    "\n",
    "print(\"Error rate: \", error_rate(cm))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7890d66",
   "metadata": {},
   "source": [
    "#### Multilayer perceptron\n",
    "Again the model finding procedure took some time. The file task4_NN_trainer.py holds the training algorithm. Here we implement the final network, and evaluate it. \n",
    "\n",
    "Again we start with defining features and genres:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "32516cc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "features    = [ \"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "                \"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "                \"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "                \"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "                \"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "                \"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "                \"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "                \"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "genres      = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f3faead",
   "metadata": {},
   "source": [
    "Get the right data and scale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "57c24914",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "X_train = scaler.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc9d12d",
   "metadata": {},
   "source": [
    "Create classifier and fit the data:\n",
    "\n",
    "**NB! Can take some time**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ddc1f026",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLPClassifier(activation='logistic', alpha=1e-05, hidden_layer_sizes=(40,),\n",
       "              max_iter=100000, random_state=1, solver='lbfgs')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = MLPClassifier(solver='lbfgs', alpha=1e-5,activation=\"logistic\", max_iter=100000,verbose=False,\n",
    "                                hidden_layer_sizes=(40,), random_state=1)\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c412a386",
   "metadata": {},
   "source": [
    "Evaluate classifier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "df5890f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error rate:  0.24242424242424243\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "y_pred = clf.predict(X_test)\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "print(\"Error rate: \", error_rate(cm))\n",
    "\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=genres)\n",
    "disp.plot(cmap=plt.cm.Blues,xticks_rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd2162a3",
   "metadata": {},
   "source": [
    "*Extra task: find suitable alpha value*\n",
    "\n",
    "First we initialise some variables and get the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4d3616b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose features and genres:\n",
    "features    = [ \"zero_cross_rate_mean\",\"zero_cross_rate_std\",\"rmse_mean\",\"rmse_var\",\"spectral_centroid_mean\",\"spectral_centroid_var\",\"spectral_bandwidth_mean\",\n",
    "                \"spectral_bandwidth_var\",\"spectral_rolloff_mean\",\"spectral_rolloff_var\",\"spectral_contrast_mean\",\"spectral_contrast_var\",\"spectral_flatness_mean\",\n",
    "                \"spectral_flatness_var\",\"chroma_stft_1_mean\",\"chroma_stft_2_mean\",\"chroma_stft_3_mean\",\"chroma_stft_4_mean\",\"chroma_stft_5_mean\",\"chroma_stft_6_mean\",\n",
    "                \"chroma_stft_7_mean\",\"chroma_stft_8_mean\",\"chroma_stft_9_mean\",\"chroma_stft_10_mean\",\"chroma_stft_11_mean\",\"chroma_stft_12_mean\",\"chroma_stft_1_std\",\n",
    "                \"chroma_stft_2_std\",\"chroma_stft_3_std\",\"chroma_stft_4_std\",\"chroma_stft_5_std\",\"chroma_stft_6_std\",\"chroma_stft_7_std\",\"chroma_stft_8_std\",\"chroma_stft_9_std\",\n",
    "                \"chroma_stft_10_std\",\"chroma_stft_11_std\",\"chroma_stft_12_std\",\"tempo\",\"mfcc_1_mean\",\"mfcc_2_mean\",\"mfcc_3_mean\",\"mfcc_4_mean\",\"mfcc_5_mean\",\"mfcc_6_mean\",\n",
    "                \"mfcc_7_mean\",\"mfcc_8_mean\",\"mfcc_9_mean\",\"mfcc_10_mean\",\"mfcc_11_mean\",\"mfcc_12_mean\",\"mfcc_1_std\",\"mfcc_2_std\",\"mfcc_3_std\",\"mfcc_4_std\",\"mfcc_5_std\",\n",
    "                \"mfcc_6_std\",\"mfcc_7_std\",\"mfcc_8_std\",\"mfcc_9_std\",\"mfcc_10_std\",\"mfcc_11_std\",\"mfcc_12_std\"]\n",
    "genres      = [\"pop\",\"metal\", \"disco\", \"blues\", \"reggae\", \"classical\", \"rock\", \"hiphop\", \"country\", \"jazz\"]\n",
    "\n",
    "# Extract training\n",
    "X_train, y_train, ids_train  = getPointsAndClasses(songs_dict,features, genres, \"Train\")\n",
    "\n",
    "# Scale\n",
    "scaler = MinMaxScaler()\n",
    "X_train = scaler.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a91301a",
   "metadata": {},
   "source": [
    "Initialise arrays for error rate and choose alphas to test:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "43b01778",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialise arrays for error rates\n",
    "error_rates_train = []\n",
    "error_rates_test = []\n",
    "\n",
    "# Make list of alphas to test\n",
    "alphas = np.logspace(-5,2,num=8, base = 10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fe423fc",
   "metadata": {},
   "source": [
    "Test all alphas and append to values to arrays:\n",
    "\n",
    "**NB! Can take some time**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "57994327",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test for each alpha\n",
    "for alpha in alphas:\n",
    "    #Create classifier\n",
    "    clf = MLPClassifier(solver='lbfgs', alpha=alpha,activation=\"logistic\", max_iter=100000,verbose=False,\n",
    "                                    hidden_layer_sizes=(40,), random_state=1)\n",
    "    clf.fit(X_train, y_train)\n",
    "\n",
    "    # Evaluate for alpha\n",
    "    X_test, y_test, ids_test  = getPointsAndClasses(songs_dict,features, genres, \"Test\")\n",
    "    X_test = scaler.transform(X_test)\n",
    "\n",
    "    y_pred_test = clf.predict(X_test)\n",
    "    y_pred_train = clf.predict(X_train)\n",
    "    cm_test = confusion_matrix(y_test, y_pred_test)\n",
    "    cm_train = confusion_matrix(y_train, y_pred_train)\n",
    "    error_rates_test.append(error_rate(cm_test))\n",
    "    error_rates_train.append(error_rate(cm_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d66342ef",
   "metadata": {},
   "source": [
    "Plot results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "008f9e4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(alphas, np.array(error_rates_train), color=\"red\",label=\"Training set\")\n",
    "ax.plot(alphas, np.array(error_rates_test), color=\"blue\", label=\"Test set\")\n",
    "ax.legend()\n",
    "ax.set_xlabel(\"\\u03B1\")\n",
    "ax.set_ylabel(\"Error rate\")\n",
    "ax.set_xscale('log')\n",
    "plt.show()"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}