final_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import scipy\n",
    "from scipy.io import wavfile\n",
    "import scipy.fftpack as fft\n",
    "from scipy.signal import get_window\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import librosa\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import balanced_accuracy_score,f1_score\n",
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.metrics import accuracy_score\n",
    "import warnings\n",
    "from sklearn.exceptions import DataConversionWarning\n",
    "from sklearn.model_selection import RandomizedSearchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Audio Load, Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "relevant_genres = ['funk', 'hiphop', 'jazz', 'rock']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.io.wavfile import read as wavread\n",
    "def ToolReadAudio(cAudioFilePath):    \n",
    "    [samplerate, x] = wavread(cAudioFilePath)    \n",
    "    if x.dtype == 'float32':        \n",
    "        audio = x    \n",
    "    else:        \n",
    "        # change range to [-1,1)        \n",
    "        if x.dtype == 'uint8':            \n",
    "            nbits = 8        \n",
    "        elif x.dtype == 'int16':            \n",
    "            nbits = 16        \n",
    "        elif x.dtype == 'int32':            \n",
    "            nbits = 32        \n",
    "        audio = x / float(2**(nbits - 1))    \n",
    "        # special case of unsigned format    \n",
    "    if x.dtype == 'uint8':        \n",
    "        audio = audio - 1.    \n",
    "    return (samplerate, audio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load ground truth file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "info = pd.read_csv('./groove/info.csv')\n",
    "#df=info[info['style'].isin(relevant_genres)]\n",
    "\n",
    "#df.pivot(index='style', columns='beat_type', values='audio_filename')\n",
    "df = pd.pivot_table(info, values='audio_filename', index=['style'],\n",
    "                    columns=['beat_type'], aggfunc='count')\n",
    "#df[df['beat'] >= 20]\n",
    "\n",
    "info = info[info['style'].isin(relevant_genres)]\n",
    "info = info[info['beat_type'] == \"beat\"]\n",
    "info = info[info['audio_filename'].notna()].reset_index()\n",
    "#locs = info['audio_filename'].to_numpy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "style\n",
       "funk       28\n",
       "hiphop     28\n",
       "jazz       24\n",
       "rock      167\n",
       "Name: audio, dtype: int64"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info.groupby('style')['audio'].count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load audio from the ground truth file and store in dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-73-70eaf167f057>:3: WavFileWarning:\n",
      "\n",
      "Chunk (non-data) not understood, skipping it.\n",
      "\n",
      "<ipython-input-75-771846dd385f>:8: SettingWithCopyWarning:\n",
      "\n",
      "\n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "\n",
      "<ipython-input-75-771846dd385f>:10: SettingWithCopyWarning:\n",
      "\n",
      "\n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error, dropping row\n",
      "size of info is now: 250\n",
      "Error, dropping row\n",
      "size of info is now: 249\n",
      "Error, dropping row\n",
      "size of info is now: 248\n",
      "Error, dropping row\n",
      "size of info is now: 247\n"
     ]
    }
   ],
   "source": [
    "info['audio'] = ''\n",
    "for index, row in info.iterrows():\n",
    "    #if index % 10 == 0:\n",
    "        #print(index)\n",
    "    try:\n",
    "        sr,audio = ToolReadAudio('./groove/'+row['audio_filename'])\n",
    "        if audio.shape[-1] == 2:\n",
    "            info['audio'][index] = np.mean(audio,axis=1)\n",
    "        else:\n",
    "            info['audio'][index] = audio\n",
    "        #info['audio'][index] = audio\n",
    "    except Exception as e: # Some files are unable to be read by scipy's wavfile read, so skipping them and removing the corresponding rows\n",
    "        info.drop(index,inplace=True)\n",
    "        #print(e)\n",
    "        \n",
    "        print(\"Error, dropping row\")\n",
    "        print(f\"size of info is now: {len(info)}\")\n",
    "info.reset_index(drop=True, inplace=True)\n",
    "info.drop('index',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Extraction code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def block_audio(x,blockSize,hopSize,fs):    \n",
    "    # allocate memory    \n",
    "    numBlocks = math.ceil(x.size / hopSize)    \n",
    "    xb = np.zeros([numBlocks, blockSize])    \n",
    "    # compute time stamps    \n",
    "    t = (np.arange(0, numBlocks) * hopSize) / fs   \n",
    "    x = np.concatenate((x, np.zeros(blockSize)),axis=0)    \n",
    "    for n in range(0, numBlocks):        \n",
    "        i_start = n * hopSize        \n",
    "        i_stop = np.min([x.size - 1, i_start + blockSize - 1])        \n",
    "        xb[n][np.arange(0,blockSize)] = x[np.arange(i_start, i_stop + 1)]    \n",
    "    return (xb,t)\n",
    "def agg_mfccs(x):\n",
    "    mfccs = librosa.feature.mfcc(x,n_mfcc = 13)\n",
    "    mean = [np.mean(feature) for feature in mfccs]\n",
    "    std = [np.std(feature) for feature in mfccs]\n",
    "    mfcc_delta = librosa.feature.delta(mfccs)\n",
    "    delta_mean=[np.mean(feature) for feature in mfcc_delta]\n",
    "    delta_std=[np.std(feature) for feature in mfcc_delta]\n",
    "    return mean,std,delta_mean,delta_std\n",
    "\n",
    "def extract_spectral_centroid(xb, fs):\n",
    "    centroids = np.zeros(xb.shape[0])\n",
    "    stft,freqs = calc_stft(xb,fs)\n",
    "    #np.sum(magnitudes*freqs) / np.sum(magnitudes)\n",
    "    for i in range(freqs.shape[0]):\n",
    "        if np.all(stft[i] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            centroid = np.sum(stft[i]*freqs[i]) / np.sum(stft[i])\n",
    "            centroids[i]=centroid\n",
    "        #centroids.append(centroid)\n",
    "    #centroids=np.array(centroids)\n",
    "    return centroids\n",
    "\n",
    "def extract_spectral_centroid(xb, fs):\n",
    "    centroids = np.zeros(xb.shape[0])\n",
    "    stft,freqs = calc_stft(xb,fs)\n",
    "    #np.sum(magnitudes*freqs) / np.sum(magnitudes)\n",
    "    for i in range(freqs.shape[0]):\n",
    "        if np.all(stft[i] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            centroid = np.sum(stft[i]*freqs[i]) / np.sum(stft[i])\n",
    "            centroids[i]=centroid\n",
    "        #centroids.append(centroid)\n",
    "    #centroids=np.array(centroids)\n",
    "    return centroids\n",
    "def calc_stft(xb,fs=44100):\n",
    "    stft = np.zeros((xb.shape[0],(int(xb[0].shape[0]/2)+1)))\n",
    "    freqs = np.zeros((xb.shape[0],(int(xb[0].shape[0]/2)+1)))\n",
    "    window = np.hanning(xb[0].shape[0])\n",
    "    for i in range(xb.shape[0]):\n",
    "        block= xb[i]\n",
    "        # Apply Window to the block\n",
    "        windowed_block = window * block \n",
    "        stft_blk = np.fft.fft(windowed_block)\n",
    "        #stft_blk = np.fft.rfft(windowed_block)\n",
    "        freq=np.fft.fftfreq(block.size,1/fs)\n",
    "        freqs[i]=freq[:int(block.size/2)+1]\n",
    "        stft_blk = np.abs(stft_blk)\n",
    "        #stft_block = stft_blk[int((stft_blk.shape[0])/2):]\n",
    "        stft_block = stft_blk[:int(((stft_blk.shape[0])/2)+1)]\n",
    "        #stft_db = 10*np.log10(stft_block) # IS THIS CORRECT??\n",
    "        stft[i]=stft_block#stft_db\n",
    "    stft = np.array(stft)\n",
    "    freqs=np.array(freqs)\n",
    "    return stft,freqs\n",
    "\n",
    "def extract_spectral_centroid(xb, fs):\n",
    "    centroids = np.zeros(xb.shape[0])\n",
    "    stft,freqs = calc_stft(xb,fs)\n",
    "    #np.sum(magnitudes*freqs) / np.sum(magnitudes)\n",
    "    for i in range(freqs.shape[0]):\n",
    "        if np.all(stft[i] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            centroid = np.sum(stft[i]*freqs[i]) / np.sum(stft[i])\n",
    "            centroids[i]=centroid\n",
    "        #centroids.append(centroid)\n",
    "    #centroids=np.array(centroids)\n",
    "    return centroids\n",
    "\n",
    "def extract_rms(xb):\n",
    "    rms = np.zeros(xb.shape[0])\n",
    "    for i in range(xb.shape[0]):\n",
    "        if np.all(xb[i] == 0):\n",
    "            r = 0.00001\n",
    "        else:\n",
    "            block = xb[i]\n",
    "            r = np.sqrt(np.sum(block**2)/xb.shape[0])\n",
    "            if r <= 0.00001: # Done to handle case when rms is 0 (for a block of all zeros\n",
    "                r = 0.00001\n",
    "            #rms.append(r)\n",
    "        rms[i] = r\n",
    "    #rms=np.array(rms)\n",
    "    return 20*np.log10(rms)#rms,20*np.log10(rms) # What is reference value to convert to dB? Is it 1?\n",
    "\n",
    "def extract_zerocrossingrate(xb):\n",
    "    zcr= np.zeros(xb.shape[0])\n",
    "    for i in range(xb.shape[0]):\n",
    "        if np.all(xb[i] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            block = xb[i]\n",
    "            zero_crossings = np.sum(np.abs(np.diff(np.sign(block)))) / block.shape[0] #np.nonzero(np.diff(block > 0))[0].size\n",
    "            #zcr.append(zero_crossings)\n",
    "            zcr[i] = zero_crossings \n",
    "    #zcr = np.array(zcr)\n",
    "    return zcr\n",
    "\n",
    "def extract_spectral_crest(xb):\n",
    "    crest = np.zeros(xb.shape[0])\n",
    "    stft,freqs = calc_stft(xb,44100)\n",
    "    for i in range(stft.shape[0]):\n",
    "        if np.all(stft[i] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            #crest.append((np.max(stft[i])/np.sum(stft[i])))\n",
    "            crest[i] = np.max(stft[i])/np.sum(stft[i])\n",
    "    #crest = np.array(crest)\n",
    "    return crest\n",
    "\n",
    "def extract_spectral_flux(xb):\n",
    "    num_blocks=xb.shape[0] \n",
    "    blockSize = xb.shape[1]\n",
    "    spectral_flux = np.zeros(num_blocks)\n",
    "    stft,freqs = calc_stft(xb,44100)\n",
    "    fft_len= stft.shape[1]\n",
    "    n = 0\n",
    "    k = 0\n",
    "    for n in range(1,num_blocks):\n",
    "        if np.all(stft[n] == 0):\n",
    "            pass\n",
    "        else:\n",
    "            sum_flux = 0\n",
    "            for k in range(fft_len):\n",
    "                f = (abs(stft[n, k]) - abs(stft[n-1, k]))**2\n",
    "                sum_flux += f\n",
    "            flux = np.sqrt(sum_flux)/((blockSize/2)+1)\n",
    "            spectral_flux[n] = flux #first flux value will be 0\n",
    "    return spectral_flux\n",
    "def get_novelty(xb):\n",
    "    N = 2048#xb.shape[1]\n",
    "    w = scipy.signal.hann(N)\n",
    "    novelty=np.zeros([xb.shape[0],xb.shape[1]])\n",
    "    for i in range(xb.shape[0]):\n",
    "        xb_square = xb[i]**2\n",
    "        energy_local = np.convolve(xb_square, w**2, 'same')\n",
    "        energy_local_diff = np.diff(energy_local)\n",
    "        energy_local_diff = np.concatenate((energy_local_diff, np.array([0])))\n",
    "        novelty_energy = np.copy(energy_local_diff)\n",
    "        novelty_energy[energy_local_diff < 0] = 0\n",
    "        novelty[i] = novelty_energy\n",
    "    return novelty\n",
    "def get_num_onsets(novelty,thresh):\n",
    "    onsets=np.zeros(novelty.shape[0])\n",
    "    for i in range(novelty.shape[0]):\n",
    "        p = scipy.signal.find_peaks(novelty[i])[0]\n",
    "        onsets[i]=(novelty[i][p] >= thresh).sum()\n",
    "    return onsets\n",
    "def get_onset_data(xb,threshold):\n",
    "    novelty=get_novelty(xb)\n",
    "    onsets = get_num_onsets(novelty,threshold)\n",
    "    return onsets#, (onsets/durationInSecs)\n",
    "\n",
    "from scipy.signal import butter, lfilter\n",
    "\n",
    "def butter_bandpass(lowcut, highcut, fs, order=5):\n",
    "    nyq = 0.5 * fs\n",
    "    low = lowcut / nyq\n",
    "    high = highcut / nyq\n",
    "    b, a = butter(order, [low, high], btype='band')\n",
    "    return b, a\n",
    "\n",
    "def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):\n",
    "    b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n",
    "    y = lfilter(b, a, data)\n",
    "    return y\n",
    "\n",
    "def get_onsets_in_freq_bands(x,blockSize,hopSize,fs,threshold=0.001,fl1=20,fh1=400,fl2=400,fh2=3000,fl3=8000,fh3=15000):\n",
    "    x1 = butter_bandpass_filter(x,fl1,fh1,fs)\n",
    "    x2 = butter_bandpass_filter(x,fl2,fh2,fs)\n",
    "    x3 = butter_bandpass_filter(x,fl3,fh3,fs)\n",
    "\n",
    "    xb1,_ = block_audio(x1,blockSize,hopSize,fs)\n",
    "    xb2,_ = block_audio(x2,blockSize,hopSize,fs)\n",
    "    xb3,_ = block_audio(x3,blockSize,hopSize,fs)\n",
    "\n",
    "    onsets1 = get_onset_data(xb1,0.0000001)\n",
    "    onsets2 = get_onset_data(xb2,0.0001)\n",
    "    onsets3 = get_onset_data(xb3,0.00001)\n",
    "    return onsets1, onsets2, onsets3\n",
    "\n",
    "def extract_manual_features(x,fs):\n",
    "\n",
    "    xb,ts = block_audio(x,2048,1024,fs)\n",
    "    centroid = extract_spectral_centroid(xb,fs)\n",
    "    rms = extract_rms(xb)\n",
    "    zcr = extract_zerocrossingrate(xb)\n",
    "    crest = extract_spectral_crest(xb)\n",
    "    flux = extract_spectral_flux(xb)\n",
    "\n",
    "    centroid_mean = np.mean(centroid)\n",
    "    centroid_std = np.std(centroid)\n",
    "\n",
    "    rms_mean = np.mean(rms)\n",
    "    rms_std = np.std(rms)\n",
    "\n",
    "    zcr_mean = np.mean(zcr)\n",
    "    zcr_std = np.std(zcr)\n",
    "\n",
    "    crest_mean = np.mean(crest)\n",
    "    crest_std = np.std(crest)\n",
    "\n",
    "    flux_mean = np.mean(flux)\n",
    "    flux_std = np.std(flux)\n",
    "\n",
    "    xb2,ts2 = block_audio(x,int(fs*1),int(fs*0.5),fs)\n",
    "    onsets = get_onset_data(xb2,0.001)\n",
    "\n",
    "    onsets_mean = np.mean(onsets)\n",
    "    onsets_std = np.std(onsets)\n",
    "\n",
    "    onsets1,onsets2,onsets3 = get_onsets_in_freq_bands(x,2048,1024,fs)\n",
    "    # onsets1_mean = np.mean(onsets1)\n",
    "    onsets2_mean = np.mean(onsets2)\n",
    "    onsets3_mean = np.mean(onsets3)\n",
    "    \n",
    "    # onsets1_std = np.std(onsets1)\n",
    "    onsets2_std = np.std(onsets2)\n",
    "    onsets3_std = np.std(onsets3)\n",
    "\n",
    "    return centroid_mean, centroid_std, rms_mean, rms_std, zcr_mean, zcr_std, crest_mean, crest_std, \\\n",
    "        flux_mean,flux_std,onsets_mean,onsets_std,onsets2_mean,onsets3_mean,onsets2_std,onsets3_std"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract features and store in dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=info\n",
    "df['mfcc_mean'] = ''\n",
    "df['mfcc_std'] = ''\n",
    "\n",
    "df['delta_mfcc_mean'] = ''\n",
    "df['delta_mfcc_std'] = ''\n",
    "\n",
    "df['centroid_mean'] = ''\n",
    "df['centroid_std'] = ''\n",
    "\n",
    "df['rms_mean'] = ''\n",
    "df['rms_std'] = ''\n",
    "\n",
    "df['zcr_mean'] = ''\n",
    "df['zcr_std'] = ''\n",
    "\n",
    "df['crest_mean'] = ''\n",
    "df['crest_std'] = ''\n",
    "\n",
    "df['flux_mean'] = ''\n",
    "df['flux_std'] = ''\n",
    "\n",
    "df['onsets_mean'] = ''\n",
    "df['onsets_std'] = ''\n",
    "\n",
    "df['onsets_mid_mean'] = ''\n",
    "df['onsets_mid_std'] = ''\n",
    "\n",
    "df['onsets_high_mean'] = ''\n",
    "df['onsets_high_std'] = ''\n",
    "for i in range(len(df)):\n",
    "    #print(df['audio'][i].shape)\n",
    "    mean,std,delta_mean,delta_std = agg_mfccs(df['audio'][i])\n",
    "    # Extract 13 MFCCs - get mean and std deviation for each (26 features) + Delta MFCCs (26 features) = total 52 Features\n",
    "    df['mfcc_mean'][i] = mean\n",
    "    df['mfcc_std'][i] = std\n",
    "    df['delta_mfcc_mean'][i] = delta_mean\n",
    "    df['delta_mfcc_std'][i] = delta_std\n",
    "\n",
    "    centroid_mean, centroid_std, rms_mean, rms_std, zcr_mean, zcr_std, crest_mean, crest_std, flux_mean,flux_std,onsets_mean,onsets_std,onsets2_mean,onsets3_mean,onsets2_std,onsets3_std \\\n",
    "         = extract_manual_features(df['audio'][i],44100)\n",
    "    df['centroid_mean'][i] = centroid_mean\n",
    "    df['centroid_std'][i] = centroid_std\n",
    "    df['rms_mean'][i] = rms_mean\n",
    "    df['rms_std'][i] = rms_std\n",
    "    df['zcr_mean'][i] = zcr_mean\n",
    "    df['zcr_std'][i] = zcr_std\n",
    "    df['crest_mean'][i] = crest_mean\n",
    "    df['crest_std'][i] = crest_std\n",
    "    df['flux_mean'][i] = flux_mean\n",
    "    df['flux_std'][i] = flux_std\n",
    "    df['onsets_mean'][i] = onsets_mean\n",
    "    df['onsets_std'][i] = onsets_std\n",
    "\n",
    "    # df['onsets_low_mean'][i] = onsets1_mean\n",
    "    # df['onsets_low_std'][i] = onsets1_std\n",
    "\n",
    "    df['onsets_mid_mean'][i] = onsets2_mean\n",
    "    df['onsets_mid_std'][i] = onsets2_std\n",
    "\n",
    "    df['onsets_high_mean'][i] = onsets3_mean\n",
    "    df['onsets_high_std'][i] = onsets3_std\n",
    "\n",
    "\n",
    "df[['mfcc1_mean','mfcc2_mean','mfcc3_mean','mfcc4_mean','mfcc5_mean','mfcc6_mean','mfcc7_mean','mfcc8_mean','mfcc9_mean','mfcc10_mean','mfcc11_mean','mfcc12_mean','mfcc13_mean']]=pd.DataFrame(df.mfcc_mean.tolist(), index= df.index)\n",
    "df[['mfcc1_std','mfcc2_std','mfcc3_std','mfcc4_std','mfcc5_std','mfcc6_std','mfcc7_std','mfcc8_std','mfcc9_std','mfcc10_std','mfcc11_std','mfcc12_std','mfcc13_std']]=pd.DataFrame(df.mfcc_std.tolist(), index= df.index)\n",
    "\n",
    "df[['delta_mfcc1_mean','delta_mfcc2_mean','delta_mfcc3_mean','delta_mfcc4_mean','delta_mfcc5_mean','delta_mfcc6_mean','delta_mfcc7_mean','delta_mfcc8_mean','delta_mfcc9_mean','delta_mfcc10_mean','delta_mfcc11_mean','delta_mfcc12_mean','delta_mfcc13_mean']]=pd.DataFrame(df.delta_mfcc_mean.tolist(), index= df.index)\n",
    "df[['delta_mfcc1_std','delta_mfcc2_std','delta_mfcc3_std','delta_mfcc4_std','delta_mfcc5_std','delta_mfcc6_std','delta_mfcc7_std','delta_mfcc8_std','delta_mfcc9_std','delta_mfcc10_std','delta_mfcc11_std','delta_mfcc12_std','delta_mfcc13_std']]=pd.DataFrame(df.delta_mfcc_std.tolist(), index= df.index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = df.to_numpy()\n",
    "np.save('./resources/working_data/data.npy', out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Feature File and classify"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "names=['drummer', 'session', 'id', 'style', 'bpm', 'beat_type',\n",
    "       'time_signature', 'midi_filename', 'audio_filename', 'duration',\n",
    "       'split', 'audio', 'mfcc_mean', 'mfcc_std', 'delta_mfcc_mean',\n",
    "       'delta_mfcc_std', 'centroid_mean', 'centroid_std', 'rms_mean',\n",
    "       'rms_std', 'zcr_mean', 'zcr_std', 'crest_mean', 'crest_std',\n",
    "       'flux_mean', 'flux_std', 'onsets_mean', 'onsets_std', 'mfcc1_mean',\n",
    "       'mfcc2_mean', 'mfcc3_mean', 'mfcc4_mean', 'mfcc5_mean', 'mfcc6_mean',\n",
    "       'mfcc7_mean', 'mfcc8_mean', 'mfcc9_mean', 'mfcc10_mean', 'mfcc11_mean',\n",
    "       'mfcc12_mean', 'mfcc13_mean', 'mfcc1_std', 'mfcc2_std', 'mfcc3_std',\n",
    "       'mfcc4_std', 'mfcc5_std', 'mfcc6_std', 'mfcc7_std', 'mfcc8_std',\n",
    "       'mfcc9_std', 'mfcc10_std', 'mfcc11_std', 'mfcc12_std', 'mfcc13_std',\n",
    "       'delta_mfcc1_mean', 'delta_mfcc2_mean', 'delta_mfcc3_mean',\n",
    "       'delta_mfcc4_mean', 'delta_mfcc5_mean', 'delta_mfcc6_mean',\n",
    "       'delta_mfcc7_mean', 'delta_mfcc8_mean', 'delta_mfcc9_mean',\n",
    "       'delta_mfcc10_mean', 'delta_mfcc11_mean', 'delta_mfcc12_mean',\n",
    "       'delta_mfcc13_mean', 'delta_mfcc1_std', 'delta_mfcc2_std',\n",
    "       'delta_mfcc3_std', 'delta_mfcc4_std', 'delta_mfcc5_std',\n",
    "       'delta_mfcc6_std', 'delta_mfcc7_std', 'delta_mfcc8_std',\n",
    "       'delta_mfcc9_std', 'delta_mfcc10_std', 'delta_mfcc11_std',\n",
    "       'delta_mfcc12_std', 'delta_mfcc13_std', 'onsets_low_mean',\n",
    "       'onsets_low_std','onsets_mid_mean', 'onsets_mid_std',\n",
    "       'onsets_high_mean', 'onsets_high_std']\n",
    "df=pd.DataFrame(np.load('./resources/working_data/data.npy',allow_pickle=True),columns=names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Correlation plot of features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "(247, 68)\n",
      "(68, 68)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x792 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# All features Correlation map\n",
    "df_cols = df[['mfcc1_mean', 'mfcc2_mean', 'mfcc3_mean',\n",
    "       'mfcc4_mean', 'mfcc5_mean', 'mfcc6_mean', 'mfcc7_mean', 'mfcc8_mean',\n",
    "       'mfcc9_mean', 'mfcc10_mean', 'mfcc11_mean', 'mfcc12_mean',\n",
    "       'mfcc13_mean', 'mfcc1_std', 'mfcc2_std', 'mfcc3_std', 'mfcc4_std',\n",
    "       'mfcc5_std', 'mfcc6_std', 'mfcc7_std', 'mfcc8_std', 'mfcc9_std',\n",
    "       'mfcc10_std', 'mfcc11_std', 'mfcc12_std', 'mfcc13_std',\n",
    "       'delta_mfcc1_mean', 'delta_mfcc2_mean', 'delta_mfcc3_mean',\n",
    "       'delta_mfcc4_mean', 'delta_mfcc5_mean', 'delta_mfcc6_mean',\n",
    "       'delta_mfcc7_mean', 'delta_mfcc8_mean', 'delta_mfcc9_mean',\n",
    "       'delta_mfcc10_mean', 'delta_mfcc11_mean', 'delta_mfcc12_mean',\n",
    "       'delta_mfcc13_mean', 'delta_mfcc1_std', 'delta_mfcc2_std',\n",
    "       'delta_mfcc3_std', 'delta_mfcc4_std', 'delta_mfcc5_std',\n",
    "       'delta_mfcc6_std', 'delta_mfcc7_std', 'delta_mfcc8_std',\n",
    "       'delta_mfcc9_std', 'delta_mfcc10_std', 'delta_mfcc11_std',\n",
    "       'delta_mfcc12_std', 'delta_mfcc13_std',\\\n",
    "       'centroid_mean','centroid_std','rms_mean','rms_std','zcr_mean',\n",
    "       'zcr_std','crest_mean','crest_std','flux_mean','flux_std',\n",
    "       'onsets_mean', 'onsets_std','onsets_mid_mean', 'onsets_mid_std',\n",
    "       'onsets_high_mean', 'onsets_high_std']]\n",
    "print(type(df_cols))\n",
    "print(df_cols.shape)\n",
    "corrMatrix = df_cols.astype('float64').corr(method = \"pearson\")\n",
    "print(corrMatrix.shape)\n",
    "'''\n",
    "HEATMAP\n",
    "'''\n",
    "import seaborn as sn\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(figsize=(15,11))\n",
    "sn.heatmap(corrMatrix, annot=False, cmap='YlGnBu_r')\n",
    "sn.set(font_scale = 1, style = 'white')\n",
    "plt.title('HeatMap Correlation')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scatter plot of features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "dimensions": [
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc13_mean",
           "values": [
            0.0005065299753636185,
            0.0006451716662795367,
            -0.00014181755951982544,
            0.0010172091639980253,
            0.0005504382312522611,
            0.0013202582810165966,
            -0.00026194402362466257,
            -0.00023978055242488176,
            -0.0004995191121987154,
            -0.0017141141990662185,
            -0.020743416791439057,
            -0.021932455574244236,
            -0.01504564910855153,
            -0.00353897854925784,
            0.000989397304196109,
            -0.023693311021340258,
            -0.0031593211704140727,
            -0.0044890602065073395,
            -0.0022904527052172675,
            -0.0004650007044469537,
            0.0003840871201553218,
            -0.0009843412155277026,
            -0.0003159850997930036,
            -0.000548568685470601,
            -0.0007271509972091593,
            -0.0009220197397262256,
            -0.0012290935693683373,
            0.0005821960430393349
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc13_std",
           "values": [
            6.734795812559488,
            7.913790395976902,
            6.540273127999084,
            7.220118503220591,
            5.7514394644194,
            7.521183381135369,
            8.94349052564764,
            6.740589275128908,
            7.318822714570384,
            7.712990232895353,
            7.519603679166442,
            8.412020965520762,
            7.628451489920372,
            8.57510214152874,
            7.520176428882243,
            7.574970550268079,
            6.528682726278324,
            6.614146205649775,
            6.462912668333426,
            8.839304856032848,
            7.503827310971661,
            7.41935446381953,
            8.685221844272718,
            7.658486145545896,
            8.6793143457866,
            8.434395478370522,
            9.041057565092558,
            8.616985928725008
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc2_std",
           "values": [
            45.27268757902408,
            53.301447409125586,
            45.27376976757957,
            49.27809279615074,
            31.60565609320662,
            46.444628914072034,
            40.59068203256712,
            43.31077298369024,
            46.397277413366616,
            40.54821930761296,
            46.37821513733834,
            46.50166714971666,
            50.35410345541453,
            38.86988091668311,
            48.70967222081293,
            44.53619095568137,
            45.368894284489436,
            50.96575301517079,
            48.34880416780866,
            43.48889501658436,
            48.00204077639507,
            51.6297653513348,
            49.70231062018762,
            43.38485172500497,
            44.13920780528204,
            53.86762810301273,
            52.42524159542201,
            51.82268583997833
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc2_mean",
           "values": [
            0.014591610062187352,
            0.005318945980958389,
            0.009725588110931185,
            0.010809005107325562,
            0.002113547837246357,
            0.009530773556374217,
            0.00038082120988185635,
            -0.019019513752016017,
            0.00588782201414271,
            -0.010603033523472274,
            0.16482727766116942,
            0.09889733863101512,
            0.1769451591697462,
            -0.004758857987564176,
            0.017790526795990417,
            0.12373966532569967,
            0.009758073918620254,
            0.03628474930611462,
            0.016420089186339477,
            -0.003163834539116613,
            0.005306355462463482,
            -0.0025707465099763503,
            0.002451194178303118,
            -0.0008744048896473247,
            -0.004121118373283868,
            0.004853917018794795,
            -0.01034959021988602,
            0.005458743807619018
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc3_std",
           "values": [
            4.853147175004903,
            4.132035792341225,
            4.557395663985448,
            3.9281443741886988,
            2.2001593247312385,
            2.7846582034148106,
            3.121916999500076,
            4.077029233793768,
            3.704503781881561,
            4.111899502723639,
            3.8274394512726353,
            3.84850539254395,
            3.1583715472536777,
            3.9731135139855662,
            4.595510575193233,
            4.758793869344932,
            4.9757490974227565,
            4.34087299348016,
            4.6228001686637805,
            2.826747876457771,
            3.7584212612075576,
            3.7209192416339683,
            3.017233997138477,
            3.680543923446013,
            3.4403707428839976,
            3.5066526324436667,
            3.0696403633726383,
            3.144534287995819
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc8_std",
           "values": [
            1.3348891589718717,
            1.379079652981736,
            1.1983650579041334,
            1.1984741132299277,
            1.0896573993443495,
            1.484738537926655,
            1.7504004560702529,
            1.1839045903570633,
            1.2222818400809454,
            1.2891504774971236,
            1.2130425533835232,
            1.197268562236535,
            1.146987197350511,
            1.3322365398346745,
            1.322911378202698,
            1.2350382647026583,
            1.3161811639945915,
            1.26640283888319,
            1.2757900928021402,
            1.0762228185476936,
            1.2952476964672524,
            1.1794643974387837,
            0.9979789789021366,
            1.2242916975201343,
            1.204851797386495,
            1.1084580241827915,
            1.228589904180774,
            1.1014252893275727
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "rms_mean",
           "values": [
            -49.51822036896139,
            -43.64314502680628,
            -49.427175017429306,
            -46.755659995265944,
            -52.3348560213027,
            -39.29540346469266,
            -44.88891964370377,
            -38.73509388715519,
            -41.557789522497295,
            -44.35831734599,
            -26.477641525706265,
            -32.101067441077944,
            -29.050200929746527,
            -37.40511124619486,
            -48.7481131999262,
            -38.690742745241856,
            -43.959917155308446,
            -42.66745743364395,
            -45.26364276747807,
            -47.009288147975546,
            -41.612796603380254,
            -42.30802423842403,
            -46.66927345931964,
            -44.09461141428306,
            -41.29471309159415,
            -42.53532783307667,
            -41.76983304787906,
            -42.217720763875036
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc9_std",
           "values": [
            1.3587603961008574,
            1.371702943097469,
            1.1932343677824602,
            1.2876132289631983,
            0.930511306700806,
            1.3147350785949967,
            1.2671107974999076,
            1.239197207126004,
            1.227310222197185,
            1.2498381780458705,
            1.2866163698258912,
            1.3181587076480719,
            1.3336007773511087,
            1.3559142633114905,
            1.348623978998527,
            1.3102342102038977,
            1.0457761958916172,
            1.0128498223926916,
            1.059293484593479,
            1.1659596292481538,
            1.3159926984430426,
            1.278194451471685,
            1.1284191073470158,
            1.252829299330122,
            1.3616503266350073,
            1.2541285316829827,
            1.404746984913709,
            1.3162851274476017
           ]
          }
         ],
         "hovertemplate": "style=funk<br>%{xaxis.title.text}=%{x}<br>%{yaxis.title.text}=%{y}<extra></extra>",
         "legendgroup": "funk",
         "marker": {
          "color": "#636efa",
          "symbol": "circle"
         },
         "name": "funk",
         "showlegend": true,
         "type": "splom"
        },
        {
         "dimensions": [
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc13_mean",
           "values": [
            0.0004592664767852773,
            0.000701352932185464,
            -0.00014365621326506743,
            0.000732274243600092,
            -0.0016971680548889703,
            -0.0004905730659917373,
            -0.00010461624169740215,
            0.001065737546557838,
            -0.002249175694648627,
            0.003926241626732241,
            -0.0035683103799836985,
            0.0008234643881620043,
            0.010468025066419952,
            -0.0029316465785486022,
            0.013777111141341142,
            -0.04641160056697215,
            -0.004542005602043364,
            0.01507582456765495,
            -0.011860814975343381,
            0.0006971794537139355,
            -0.025939544547308985,
            -0.0011498676768163184,
            -0.0005983603902891368,
            0.0009974334583112544
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc13_std",
           "values": [
            7.945062766957551,
            8.077608719831657,
            8.067922994287288,
            6.4713740270588875,
            7.438963631522092,
            6.381995844766026,
            8.153618503841566,
            8.061797978227508,
            7.761848296290687,
            3.280493872810143,
            5.148066419860092,
            5.2420882629157655,
            3.6601227137207304,
            10.781153834225702,
            4.980172071748131,
            6.314410432646465,
            7.446769131138138,
            5.031709471083934,
            5.987466030791114,
            9.653470876632248,
            5.273637324935711,
            6.331161345358488,
            6.090030862618421,
            7.969036265841607
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc2_std",
           "values": [
            42.751709372848346,
            41.2485802996028,
            42.17734262542586,
            49.416815036473366,
            43.63953435766078,
            42.38716955164767,
            35.28930904786938,
            37.765251911246885,
            35.502892879953535,
            29.457039590048925,
            38.514065917403954,
            30.011338044401924,
            24.21082826794867,
            39.42422942217867,
            14.665043266201218,
            11.246835202391832,
            29.612703839395856,
            16.86065051190152,
            19.99798198704581,
            37.24613904528515,
            31.728933491552137,
            47.572323308082595,
            29.001219805495364,
            32.96655415671318
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc2_mean",
           "values": [
            0.008112608671096536,
            0.005051804974387018,
            0.006533707445386212,
            0.009304722015906236,
            0.009470983909666853,
            0.00825380419205401,
            0.0017851288960221694,
            -0.010167941493556739,
            0.012389455766340799,
            0.007926046787778123,
            0.09362842319109138,
            -0.07473579706902993,
            0.1529559110272539,
            0.0005976232341590929,
            -0.005718470429080562,
            -0.06727132613570799,
            -0.061781980604209884,
            0.15446474077004563,
            -0.15894340445093874,
            0.003414378634653523,
            -0.08104963990278723,
            -0.029994460821524373,
            0.003797120510396599,
            0.006112663793423319
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc3_std",
           "values": [
            2.6976123758182986,
            2.6941246163070662,
            2.95621285529784,
            2.6948984779298732,
            3.3254528524406775,
            3.715637225591779,
            2.9142335877782917,
            3.1023003148667456,
            2.024015463441602,
            2.2164216869110938,
            2.446492392838005,
            3.2229546575217607,
            3.3469458339390457,
            3.0875888937974723,
            3.8065092690032873,
            3.863499429970404,
            3.3894625779426,
            4.072345535258682,
            3.7999580483545023,
            2.111025306323582,
            2.108547413485258,
            4.86539122694577,
            2.2790900437282593,
            2.7343995451762066
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc8_std",
           "values": [
            1.8753165030980614,
            2.077287235681329,
            1.8488384837795055,
            1.3021194194229238,
            2.1894945400655104,
            1.132418129308609,
            1.1209290539679853,
            1.1158035844792413,
            2.0411333620289014,
            1.076822858467839,
            0.9019450328133757,
            1.008555377875711,
            1.2464499465833063,
            1.7351194120061666,
            0.9412187664177907,
            1.1053288726760457,
            1.0068856673341293,
            0.9481815961274884,
            1.1251915882539116,
            2.0552005098254194,
            0.9256559504963401,
            1.2018010071309673,
            0.8818110686832413,
            1.207070225081169
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "rms_mean",
           "values": [
            -47.78640586930105,
            -47.952027671467405,
            -46.807230250484025,
            -56.04878553113381,
            -46.33293959128298,
            -32.68504930428436,
            -55.846377588050345,
            -50.65985551984909,
            -56.388246796117585,
            -64.32706312816232,
            -51.52309200412843,
            -35.59660048409105,
            -25.028075582738424,
            -38.639247784528315,
            -22.170032193061115,
            -26.71166570521428,
            -31.701735415418398,
            -23.031079055253016,
            -28.012380690846644,
            -47.63818152514282,
            -46.56361399796525,
            -36.53131527987932,
            -62.37102726218279,
            -57.395821618643204
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc9_std",
           "values": [
            1.1500547867880309,
            1.2011838474683558,
            1.2232318410859209,
            0.980843580027118,
            1.1799427965093467,
            0.9662768636243128,
            0.9879629738658515,
            1.0656278065338087,
            1.0977417756725931,
            0.8601217850341986,
            0.8150789580211966,
            0.757909842840763,
            1.0678225812090525,
            1.0678128155235032,
            0.9659963855578081,
            0.8681363022297665,
            0.8763388396715315,
            0.9000673148578006,
            0.994509844923086,
            1.2584134417167943,
            0.8505704583408301,
            1.1642561186120206,
            0.7661383281266009,
            0.9381531350025271
           ]
          }
         ],
         "hovertemplate": "style=jazz<br>%{xaxis.title.text}=%{x}<br>%{yaxis.title.text}=%{y}<extra></extra>",
         "legendgroup": "jazz",
         "marker": {
          "color": "#EF553B",
          "symbol": "circle"
         },
         "name": "jazz",
         "showlegend": true,
         "type": "splom"
        },
        {
         "dimensions": [
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc13_mean",
           "values": [
            -1.6299386240220027e-17,
            -0.0003020406830525467,
            -0.00030271247899806426,
            -0.0007691208974201904,
            0.0004910693514426585,
            -1.7873559529569084e-17,
            -0.001688805595376929,
            -0.00003306218361203353,
            0.0001804676290116221,
            -0.004900334292212497,
            -0.007485607139018549,
            -0.0008403968147201866,
            -0.004032529003032429,
            -0.004280313241898438,
            -0.001119946814008023,
            -0.017224757043019442,
            0.0009651241401522247,
            0.004713810517766657,
            -0.013632331294161984,
            0.010924554921932289,
            -0.02037836538716357,
            0.005612002977128549,
            -0.015267432510464068,
            0.0009500027351641606,
            0.00014848952959796235,
            -0.01845503841105918,
            -0.004152579542807755,
            -0.0573261328515745,
            -0.06527121124132429,
            0.038241832891641445,
            -0.0006654838446074192,
            0.0534533551627215,
            0.007290918502957365,
            0.07125896732410338,
            0.027500827847547107,
            0.010840346662249244,
            -0.004022138854864867,
            -0.033901803523896,
            -0.024466687352479508,
            -0.01401359760351292,
            -0.00541466811766711,
            -0.005832637417875125,
            -0.01577991900828298,
            -0.0005429821979200728,
            -0.006947111816427041,
            -0.0020686325484044594,
            -0.0005640709980585352,
            -0.001802831095542362,
            -0.022288616815342374,
            -0.018439459302356857,
            0.005152987325911096,
            -0.01649255051633644,
            -0.012638097395819236,
            -0.003964820407530442,
            0.009342064637611051,
            0.012281776486730192,
            -0.04386958233589197,
            0.0006176753941082077,
            0.0009614554038959623,
            0.014027949473102732,
            -0.0037759077605069922,
            -0.0200777046042954,
            0.00041114729927204427,
            0.0031637607114832463,
            -0.0033823426548270454,
            0.005080627216621744,
            -0.010660131995654274,
            -0.011643034878861494,
            -0.016430575348450698,
            0.003947042229235468,
            -0.005601313654719125,
            -0.011037861065808181,
            -0.012595174398054052,
            0.004857739308022781,
            0.0005282915339493658,
            -0.007697082725271603,
            -0.02220429274950258,
            0.002025266661000205,
            -0.00031005327519357737,
            -0.014067795088734424,
            -0.00937357603909776,
            -0.013090287721386838,
            -0.0012309517211951295,
            -0.00004902043877494874,
            -0.0008444753319866684,
            -0.004118974329227722,
            -0.00185072719412764,
            -0.004772625482751376,
            -0.0014409023011742776,
            0.0018992071809623811,
            -0.0021512961422784967,
            0.00009958078159352199,
            -1.4366711770163168e-17,
            0.00008320340381762823,
            -0.0001448232488737617,
            0.000424274051525223,
            -1.2955300974996618e-17,
            -0.0009183969351182378,
            -0.0005818548565666257,
            -0.0023533036122874245,
            -0.0020652353782839796,
            -0.002718555876263192,
            -0.001492786110203429,
            -9.630726894891196e-18,
            -0.0027788033261616466,
            0.013237448110550458,
            -0.00408365899406494,
            -0.0012062249533548596,
            0.015030150940944837,
            -0.035124387406825164,
            -0.007188536208035176,
            -0.00009120910283864923,
            -0.001386929692779137,
            -0.0006742203242780068,
            0.0607860257287646,
            -0.002084432855250709,
            -0.002114359278820379,
            -0.0009520521116284147,
            0.0015568139625083133,
            -0.003832895477686105,
            0.0003969238682270605,
            -0.014282773115509045,
            -0.04316820461697022,
            -0.005685580677226407,
            -0.003781034924428988,
            -0.0023325301595082644,
            0.0017291902687483448,
            -0.0020167190946621173,
            -0.0021912549170699748,
            -0.0015032354604441534,
            -0.0006740734663604404,
            0.003468954265147597,
            0.003524852803808667,
            -0.001240825255148542,
            0.00019940457472984475,
            0.002195527330103539,
            -0.0008557476814760833,
            -0.0014271157987981087,
            -0.04443163085171452,
            0.048717239276829055,
            -0.008286470929736969,
            0.0016548573797056795,
            -0.0006785253529543562,
            -0.008825756493153583,
            0.02241425698631237,
            0.018655756359969782,
            0.0047383270467755345,
            0.001074344472007381,
            -0.0030113716967190974,
            -0.000460680679992108,
            -0.006328959023777081,
            0.0030010173278216304,
            -0.0026252680155947447,
            0.002803330013759966,
            -0.0008871074775664543,
            -0.002506129981940272,
            -0.013840298132203875,
            -0.0046311925052279655,
            -0.004113146924881682,
            -0.00010834796127812542,
            -0.010295455959579064,
            -0.01027398266861494,
            -0.00032075865286924015,
            -0.019091262818897253,
            -0.01166113793311315,
            -0.009315296757971171,
            0.0075042526072659765
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc13_std",
           "values": [
            9.825042142197423,
            7.78755161838051,
            8.168544418883775,
            4.8775908878442165,
            8.674617750165682,
            6.983601015735111,
            6.805665318220841,
            6.981101652698445,
            7.473634959079529,
            5.240569976869959,
            7.1518476767158505,
            7.439738165741499,
            6.608043000565333,
            4.852754264602115,
            7.263835425915223,
            6.517380509910992,
            5.653995102695007,
            4.649958845074132,
            6.267702861834536,
            7.669434169366341,
            6.881592114125242,
            5.661389926463038,
            6.506484119220735,
            5.9326720887757265,
            8.770262656860375,
            5.544029051233508,
            5.823645187061774,
            6.740007644605357,
            7.368309260948751,
            7.227099558893287,
            7.263630612021717,
            8.344340965113359,
            6.915910698367044,
            8.669704611792618,
            4.171176445863452,
            5.240897128290704,
            3.746106455622807,
            3.1567203060053743,
            4.00517816857609,
            7.492532423909165,
            5.736286668336162,
            5.610796547307543,
            6.238518109697396,
            5.973791813467722,
            6.849290258413118,
            7.266412865674241,
            3.5730784346708737,
            7.615587315589855,
            6.840886176206226,
            6.881358424045962,
            6.746572560756403,
            6.689836102542541,
            7.125506667547878,
            7.425802241067574,
            6.393570904975818,
            5.5623725570859754,
            5.7685954164588935,
            4.5752901602271,
            7.530578906736441,
            6.464993603515168,
            7.427218790862187,
            7.077725437695284,
            7.71090155102385,
            6.2977884308736805,
            9.120192061609625,
            5.546873452225978,
            6.530513898791042,
            6.517045927226593,
            6.000985594577982,
            6.422458238977998,
            7.79489421928008,
            8.18790130870939,
            6.831029834501915,
            5.647898316330963,
            6.972394130384372,
            6.854321317467896,
            6.980721186011895,
            4.862683813699328,
            6.573728676477194,
            7.295178237282446,
            7.302347707077684,
            7.650896692463815,
            8.254340647666607,
            8.028654536507455,
            8.818457597735119,
            8.249334430915916,
            8.031048238391548,
            7.945051195350059,
            8.276599330711107,
            7.65696059384268,
            8.788236088301218,
            7.2445452815129245,
            8.208871674552253,
            7.615679710584336,
            8.175610138554001,
            7.359726078675017,
            7.144254361750355,
            8.182506348690737,
            9.091756270496475,
            4.9412312010175485,
            7.130245202552681,
            6.859504808995106,
            6.876830856130242,
            6.86534685027308,
            7.9596459076175545,
            5.28132741979424,
            7.570506446952061,
            7.3373533524862005,
            6.501488422882126,
            5.183030302342952,
            8.138171196575627,
            7.348455789011764,
            7.8845838571787,
            7.972441191556609,
            6.672028900204063,
            7.131827144903277,
            6.721761033455712,
            7.9987865821330955,
            6.4954984092911,
            6.157960882263261,
            7.441798494573625,
            7.543658170412536,
            6.706386598304002,
            7.314421187084593,
            7.142425788578405,
            7.44531163838099,
            7.315187240889171,
            8.4695345357315,
            7.366776791705935,
            7.721176670056621,
            7.441944220105142,
            8.465633634573722,
            8.24171374129477,
            8.803937174305627,
            8.233693400174694,
            8.236462381450028,
            6.176513619443447,
            7.579056932084079,
            8.875635990539337,
            7.3288236240014735,
            6.8583707827562215,
            6.069581733970605,
            7.239312732885256,
            6.932768355467128,
            7.13420428130051,
            4.515941990013362,
            6.21316129572928,
            4.942544637694713,
            6.865553765781454,
            6.410868806678518,
            7.383883216368553,
            6.842610482882826,
            6.89811148680162,
            7.51063802493742,
            7.037082041073902,
            7.367575474966834,
            7.879268899503678,
            7.0505092819519675,
            6.734747264260998,
            7.168935688005405,
            5.712991764690664,
            7.593272480524515,
            7.6115598073265955,
            7.475036409036648,
            7.6809395105451115,
            7.024818149482296,
            8.42180642746426
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc2_std",
           "values": [
            38.85176213409963,
            43.803850649361436,
            43.268783376131424,
            38.84765853184974,
            44.77526461483546,
            45.247680993098434,
            53.30280109369162,
            54.15979834961996,
            50.56642659041486,
            14.50438436656133,
            26.65116995540297,
            29.526778045136403,
            43.48653794052994,
            36.791938202189954,
            45.24007919254969,
            48.13027808987256,
            21.89388594270642,
            31.32136026232741,
            35.02661242204676,
            17.922525012447778,
            16.972993339474826,
            21.494473828200746,
            43.27256151413708,
            47.791771126183086,
            16.482954061402626,
            32.52588303707269,
            54.88301343065449,
            42.56139294027466,
            37.859399755698654,
            41.49388971505965,
            30.05642288969218,
            18.77863045783394,
            16.651624581090296,
            16.155152544580126,
            25.73972183914954,
            23.288958713514607,
            23.816807942489337,
            23.878126116258766,
            39.5428577183853,
            45.00658363662131,
            42.69416422376716,
            23.797859163364695,
            43.6311335927821,
            33.72070114684987,
            55.957252465489994,
            42.30439739290185,
            24.336574565690665,
            34.19743462510486,
            27.60200492576124,
            28.12940130682812,
            34.05616756177278,
            29.319205838656554,
            29.78142100614243,
            24.511312470034863,
            30.592615649598695,
            47.211287220343245,
            35.011399114937284,
            25.379900021718274,
            28.446729419520665,
            30.052013228534964,
            33.727350648547535,
            21.28988471854968,
            29.98948912158856,
            33.30558450631871,
            38.248935395628145,
            37.85973008808828,
            26.898245561435786,
            19.436891324677248,
            22.461051997924507,
            25.069565424258162,
            30.58179323355953,
            26.18939234142044,
            35.541155251604295,
            42.625380642450196,
            39.949455301003944,
            27.15662931786207,
            30.195787798812216,
            27.797342241429373,
            36.78676054003448,
            40.57817412098208,
            39.80605632666833,
            32.40211132765167,
            52.925581147030826,
            30.783911437661555,
            43.6985648917375,
            58.295480175638346,
            59.30819466860658,
            45.37961747613504,
            44.09854692100194,
            51.53893494825657,
            33.535484942919666,
            36.86341460469031,
            46.64664403388221,
            39.341129225069956,
            46.566688718949266,
            48.978328560653054,
            51.64840316679885,
            48.81523151760153,
            29.687209790550074,
            32.51086531129768,
            40.73105984910825,
            40.69137912173943,
            47.239160639636886,
            52.92638540931572,
            42.112484206287974,
            38.80791702511405,
            50.75360072542167,
            29.16652369075729,
            47.61044609999415,
            46.68199526761572,
            34.23764957711186,
            33.35733052957069,
            33.16258174487505,
            40.55271233743328,
            40.68554822718125,
            39.296651057030054,
            35.30943062578332,
            47.01991141010542,
            33.92633171248195,
            49.09100348457916,
            34.38987759765096,
            32.43696583880521,
            41.00624250283886,
            35.14185650252923,
            45.72306714862216,
            40.86296799161992,
            42.83818434260614,
            45.73617159667303,
            39.53210783188214,
            49.0737975885739,
            57.14290644024329,
            57.706839922493636,
            62.75595347393782,
            59.107842970063466,
            47.46402896950669,
            44.741998466743034,
            53.97709175070523,
            42.81917200713477,
            46.22297431622821,
            35.6272676704076,
            39.208669186583776,
            37.29233922434934,
            40.12865267894753,
            30.327632946171715,
            47.737885012746425,
            15.822744554167983,
            36.25489357131939,
            27.12668001289962,
            50.60786402473951,
            44.70511019742409,
            38.01547131662022,
            40.656081913994534,
            48.37230007653792,
            43.325399390018575,
            46.18788774898558,
            38.95897953189402,
            39.91802418305411,
            31.980749813195388,
            31.051763111209695,
            47.05653453142392,
            41.55731320768728,
            32.46157931997521,
            40.43320802181319,
            27.290453384503255,
            46.34520783167501,
            46.530678068868504,
            42.571366905480346
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc2_mean",
           "values": [
            -7.661632402182522e-17,
            -0.0010350317740141905,
            0.00025294673608452367,
            -0.004109963166074901,
            0.000608485782393345,
            -1.0593883057202081e-16,
            0.022871942052055273,
            0.00009669088389164968,
            -0.007791473359574856,
            -0.012049443738361776,
            0.041858455720658425,
            -0.009753797942826634,
            0.016067153842896885,
            -0.0020275926242841235,
            0.010736611038158626,
            0.04456680627632428,
            -0.02383325941169482,
            0.015559358337788067,
            -0.03367890271458549,
            -0.2349712327530296,
            -0.6370633719466676,
            0.3564121394345188,
            -0.2519418599094046,
            0.030971753557149984,
            0.12453601807597428,
            0.08549370927729996,
            0.01888514374865556,
            -0.6986263875606549,
            -0.5546217899362541,
            -0.5474921649513041,
            0.04488583767840874,
            0.07434282750701796,
            0.026434947516528043,
            0.20910171406916828,
            -0.5559992684574435,
            -0.11549260473685388,
            -0.02099114456096938,
            -0.5010784720262891,
            -0.1706518473256008,
            0.13469300655257355,
            0.011506437257492959,
            -0.05823839198800785,
            -0.027838688924812713,
            -0.13463646856524,
            -0.007031750879881263,
            0.010637605891801022,
            -0.009794588611863102,
            0.0022683352613808894,
            -0.02119699647137933,
            0.05665938587432953,
            0.02965204303024969,
            0.20175484871454644,
            -0.04568856795198753,
            0.005617500689899297,
            -0.046142691034677795,
            -0.10993961531471685,
            0.10908247763660432,
            0.02959266139877896,
            0.026788303135275113,
            0.042791277362785866,
            -0.028307583539996524,
            0.28297482071819996,
            -0.01608516410590821,
            -0.017369685129534285,
            -0.012751685985123653,
            0.08490158033964597,
            -0.019719568672948763,
            0.015860433869915876,
            0.013323017484986634,
            0.08001507806112997,
            -0.004089001006424486,
            -0.17921672793186078,
            -0.0911556744855699,
            0.04210237856608224,
            0.027901072066881676,
            -0.06680936909450784,
            -0.08930260667216548,
            0.007245863863616912,
            0.00039005702026858024,
            -0.020727915618089763,
            0.012456733242779603,
            0.014618618571241623,
            0.01456531291593035,
            -0.0024839938630131734,
            0.0019374559054378187,
            0.025563962662041043,
            0.0028141460194906457,
            -0.020496170063693083,
            -0.013933850659581401,
            0.010630102674423011,
            0.0009246653989051744,
            0.004124627849671758,
            -1.3408930985485623e-16,
            0.0003849347447751338,
            0.0026858308221606305,
            0.0016576164708619538,
            -1.2437088935996752e-16,
            -0.009801476497948344,
            0.0010918182946540922,
            -0.015632911212632064,
            0.01018824792377522,
            -0.01635748823987255,
            -0.005664306610547706,
            -4.9178179888806105e-17,
            -0.0015911424600939272,
            0.21311665261844961,
            0.005949364553693987,
            -0.0022216249945936797,
            0.11650009973633184,
            0.4801443737232109,
            -0.020521608975412484,
            0.000031462358818093285,
            0.0035497055601264368,
            -0.011734233229844486,
            0.26189739397371953,
            0.008693628680112517,
            0.015839994328845863,
            0.0032236223657797266,
            -0.008336658381515058,
            0.020281007051384137,
            0.017807836279568827,
            -0.07274647228125072,
            0.20713357171753222,
            0.016338786889585823,
            0.010737841631081057,
            0.005804578575625472,
            -0.001509911228627646,
            0.005683226096201416,
            0.008145446283650125,
            0.019583438898219813,
            -0.00505934582844928,
            0.016031628550510768,
            0.020433597081840463,
            -0.025351207025788004,
            -0.0005436534740755732,
            0.013473999704744603,
            -0.008483216872050003,
            -0.02860069468464382,
            -0.14374881716678958,
            0.21051094885950164,
            -0.10983530920729626,
            0.018863640709759183,
            -0.0006823502158766882,
            -0.012075737787539469,
            0.10744302127018511,
            -0.030197221340623377,
            0.038198018248451655,
            -0.033253938767596455,
            0.011362934601956465,
            -0.0018421851775362688,
            0.26707915093479523,
            -0.006488615437256804,
            0.010592066878530225,
            0.0070906137124446605,
            0.007103383892493626,
            0.03523172977810261,
            -0.04326366599943307,
            -0.017500294925692016,
            0.09343568243508928,
            -0.00012200861050213107,
            -0.039424175696551274,
            0.12625537189175345,
            -0.0070437770770295435,
            0.10391270752248986,
            -0.004393712917987715,
            -0.02367499778566984,
            0.027301005923013984
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc3_std",
           "values": [
            2.3386540424175273,
            3.1636812408576573,
            3.811245089796493,
            4.3383549655351,
            3.5091258390044264,
            3.4544240822004477,
            3.979843393059399,
            3.9653260384488482,
            3.7910331857712722,
            3.492604223301911,
            2.9165626456832556,
            2.9251416214680863,
            3.888820686801685,
            2.8948649985315633,
            3.6268354898035122,
            3.7715149577364113,
            2.0612871677635365,
            3.4834902805156465,
            2.6490063455416033,
            3.770668613601586,
            3.6513740707534716,
            3.7023257077419642,
            2.7997088863719037,
            3.7565812761586477,
            3.0894061593235445,
            1.6724686362446963,
            2.817784135106644,
            3.6759976857629204,
            3.6570692001668603,
            3.6316276927725863,
            2.691777294601804,
            3.9080374482337943,
            4.763647747427146,
            3.040295891033628,
            2.6093483186118807,
            2.5604358062625203,
            2.506012125801518,
            2.742504117480523,
            2.229004219785054,
            3.7088868596471687,
            2.66041746574037,
            3.4571710982663966,
            2.5744317201271536,
            3.2584019952470884,
            3.6035153209653754,
            3.2879792577913602,
            4.76699974869664,
            2.6555424259543843,
            3.8687131342235404,
            3.556113384255341,
            3.932484071076805,
            3.496120977728384,
            3.3108684096794687,
            3.039507063597223,
            2.6777303672285084,
            2.975042675989317,
            1.9650716167660836,
            4.969036637454223,
            3.2983349207218873,
            3.0953927597803195,
            3.4248768103854386,
            2.855694328724925,
            3.2349326037002575,
            3.5767355086904153,
            3.1134445588072777,
            4.521424677439575,
            2.011763172707869,
            3.478157908855246,
            3.906103466134787,
            3.4462373657075434,
            3.1263641895759613,
            2.8091387301317168,
            4.250769548497093,
            2.7325101944472214,
            2.959978386714798,
            3.4327305213028683,
            2.6258376839906186,
            4.8933801620268,
            5.142000835386562,
            3.0147114256311967,
            3.05738844202774,
            2.7635295036356173,
            3.1223855683307655,
            3.2865516516579807,
            4.0165942346585,
            3.2617092685481723,
            3.4410288848490422,
            3.4958426796664384,
            3.798275554411208,
            4.470723790492488,
            3.5297162362227534,
            2.5250508265836213,
            3.621193420299404,
            3.192632171476762,
            3.2198673094616503,
            2.9535323743068376,
            3.2084492219664558,
            3.3423177113343727,
            2.8911155558724686,
            3.074870873998152,
            2.4876966152157802,
            2.5089184676057887,
            3.021181278448658,
            3.153585911528501,
            3.0134553811727347,
            4.573644355335835,
            3.336867752512926,
            3.407108488326959,
            4.845661690349987,
            2.926367116010292,
            3.553143916535012,
            2.9230325384948985,
            2.3795843079201626,
            2.8157077912754978,
            3.4431750998506803,
            2.3483302542518927,
            2.1487496121563567,
            3.407262780263722,
            4.500175012771502,
            4.333593421536363,
            3.6015968246001777,
            5.301322758776909,
            2.573875548074717,
            3.8621457014713116,
            3.3536502556177044,
            3.2537813494212235,
            2.8941703517080195,
            3.066372708269324,
            3.1697037648474597,
            2.812633977669032,
            3.7212950725411833,
            3.6710226576430403,
            3.4253427255333104,
            3.6711807796750207,
            3.719277503151632,
            3.2075395601193546,
            3.3647832185771747,
            3.158733640945818,
            3.529933090194326,
            3.494249234990907,
            3.0233282987589973,
            3.238042065218597,
            3.5611433069693756,
            1.8964814510208372,
            2.6034909302475526,
            4.1039991286739514,
            3.9704287677794174,
            4.186932718076589,
            3.678765747528869,
            3.330693296967368,
            2.2987177151224767,
            3.375792812961467,
            3.169969177086108,
            3.14937207818846,
            3.5422091490774035,
            2.665691276097191,
            3.530613924256749,
            3.424715529860959,
            2.931332638272846,
            3.050548594096114,
            3.5097317337865617,
            2.269283708821809,
            3.2523272971005768,
            3.414347445117207,
            3.513413374296669,
            3.9343771121791806,
            3.8594953777423795
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc8_std",
           "values": [
            0.9457313119462883,
            1.2277853577088824,
            1.319823956184864,
            0.9055050106659556,
            1.0448545684753838,
            1.3563272841147311,
            1.3175761383443776,
            1.3460864501327836,
            1.6129302278297688,
            1.2445976056325303,
            2.48733136863832,
            2.4017889296508588,
            1.401190650190409,
            0.614777234655685,
            2.1287080933236484,
            1.4475539598135623,
            0.9698067402953454,
            0.9476433199804608,
            0.9455470279761946,
            1.2441325484807209,
            1.2568425550986992,
            1.2565471624833415,
            0.9012564231405408,
            1.4079685513727578,
            1.041452173920869,
            1.7893315183433538,
            1.7705578069207473,
            1.1039859674567873,
            1.0527719316125934,
            0.9546090780592664,
            2.0185571622698264,
            1.0063388757755394,
            0.9493193876166447,
            1.1028632856975893,
            1.047264896549458,
            1.1825209660746834,
            0.9685666446520131,
            1.0157634902516708,
            0.8028142121901152,
            1.1947807265244819,
            1.0874348958359916,
            1.0244943117026502,
            1.0926765711967392,
            1.0977551848293285,
            1.4085316039336933,
            1.9081682036897947,
            0.9329418812500981,
            1.1386672701259302,
            1.654866194646788,
            1.6387184783836202,
            1.686120708809802,
            1.6421886354990358,
            1.5526312963302589,
            1.5644769966888818,
            1.0969482783081046,
            1.220867606708962,
            1.0094425300114096,
            1.0183218829997072,
            1.2275176288314833,
            1.2490221708773057,
            1.2739509017887019,
            1.9604439357368062,
            1.6911727842477184,
            1.1410260064955589,
            1.1446319631036304,
            0.7020768000016653,
            1.2575508822323065,
            1.5897609823697962,
            1.620216363895723,
            1.5041411797372455,
            1.5601710374799918,
            1.1735192661279805,
            0.7989601770765948,
            1.0814190338160639,
            1.0836114551378622,
            1.6466833504373142,
            1.5438170259146295,
            0.8006618718425788,
            0.7413415698059339,
            1.198323482913275,
            1.154787860115082,
            1.1822116823418398,
            1.0491291705462051,
            1.5687732921833895,
            1.4720231256467275,
            1.200711936139211,
            1.196126895391273,
            1.2824000728550684,
            1.3922104893838294,
            1.3787840762359613,
            1.342152009239704,
            0.7892778241222829,
            1.216075952903022,
            1.0309100824540272,
            1.141862085858294,
            1.2161872661942623,
            1.4335068717437103,
            1.2497310756420226,
            1.231096720886429,
            0.696084543211191,
            1.0817147605045936,
            0.9481322844235726,
            1.1612845643954692,
            1.0703295364858618,
            1.0736460123087819,
            1.1175523010391437,
            1.085718118256087,
            1.2047818567187638,
            0.9165442288598863,
            0.7965059007546127,
            1.1337946773286012,
            1.0273895904575088,
            0.8937285745789598,
            0.9790084693717582,
            0.9889199477505733,
            0.7811996368010604,
            0.8873555641321131,
            1.0595414234794334,
            0.8756490175503759,
            1.0871472890798448,
            1.4150673129907765,
            0.8472144024621447,
            1.2283817510654715,
            1.3941448937314853,
            1.0943395655885169,
            1.1732528139690388,
            0.8051981628155175,
            1.0798357191786214,
            1.3256918103001727,
            1.555114159316114,
            1.3849823503399266,
            1.3451215859056582,
            1.3235567840767009,
            1.3290506208596158,
            1.7564796118795079,
            1.644382144784082,
            1.3305816933906098,
            1.1711770457579336,
            1.4074557891982387,
            1.6202222841534324,
            1.2346905847368645,
            1.5302599497504892,
            1.2311266245063581,
            1.1696869860568824,
            1.2605840663800103,
            0.9218906354347152,
            0.8846770938560554,
            0.916602718555442,
            1.2843653481833048,
            1.2753602415798517,
            1.2937943686229025,
            1.3992312098833075,
            1.1486386945976375,
            1.5073017584202868,
            1.2404306183590068,
            1.4089285230793944,
            1.0141899788236033,
            1.5827809691182086,
            1.5442113073493557,
            1.1878352658898204,
            1.63655756221199,
            1.261645606775259,
            1.5750774094617461,
            1.8426909164291287,
            1.1745077711718392,
            1.3900009592367966,
            1.321179877497876
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "rms_mean",
           "values": [
            -60.25390726028672,
            -45.14042185593923,
            -47.7463158521377,
            -34.31304343943274,
            -46.51956919078778,
            -34.99990618748147,
            -28.92190822586265,
            -36.750679822664175,
            -45.59659587652146,
            -34.990099965375066,
            -42.36977255067432,
            -41.12914714454959,
            -41.75635703269908,
            -64.3668361957995,
            -46.84238857472792,
            -41.47557428643529,
            -35.51875831129954,
            -41.338236741178996,
            -31.262527423011868,
            -17.22489197475491,
            -20.500030554191436,
            -30.199362552794298,
            -28.7810896659265,
            -40.84918667505533,
            -16.069453477439765,
            -34.519287404334186,
            -41.70974984927827,
            -27.114238709143404,
            -19.057704212570304,
            -18.00799123598158,
            -39.70555373949524,
            -16.54224418846366,
            -17.375224261570278,
            -16.5562040952898,
            -17.454439229031696,
            -24.127889625964997,
            -22.076388242285553,
            -19.400182891558014,
            -52.85890403255463,
            -22.26474166152011,
            -21.74265122490714,
            -46.85154803978888,
            -21.173799005035217,
            -37.44727633210283,
            -41.85404734977051,
            -46.751865109438995,
            -31.000253785196836,
            -49.69559950207234,
            -33.068594895630675,
            -30.577823885164523,
            -35.96503103293629,
            -31.281401169102168,
            -36.595783458878834,
            -44.29488140539374,
            -47.621852806067466,
            -31.157656819194663,
            -52.61895706810682,
            -29.5143638662738,
            -44.2252757736283,
            -36.616945844881336,
            -38.507192857405755,
            -30.490116937321165,
            -38.6783091846379,
            -30.012203443435,
            -34.36611874642715,
            -36.48582477297069,
            -43.46999939912037,
            -38.4193687288216,
            -30.091404413757996,
            -25.946004273752724,
            -37.8019195422254,
            -40.182765952624514,
            -31.035449348850733,
            -48.841777243334164,
            -49.892704000624924,
            -33.11336050741556,
            -33.62961380391867,
            -33.60676829186398,
            -37.03512573199756,
            -41.3360789555069,
            -36.88598033496445,
            -39.79382186546597,
            -44.37831647304522,
            -38.534099966807105,
            -43.29556523130979,
            -39.13460250305038,
            -38.93794060857011,
            -32.999237197771876,
            -37.090321207648394,
            -28.105298444578466,
            -36.15606388083476,
            -49.70544896372793,
            -48.707807212816874,
            -52.0966370748742,
            -49.727056378462024,
            -37.41546326786491,
            -36.636193832770516,
            -38.685859699000524,
            -54.468339962127644,
            -37.228510734040455,
            -47.238016620786915,
            -51.10520286397626,
            -49.22820148131021,
            -46.95595300883173,
            -37.972420037641896,
            -21.33304674171446,
            -39.26987698056584,
            -35.00817017341584,
            -31.20558260162605,
            -61.15336978270506,
            -23.870084002110136,
            -28.096006158523338,
            -54.83650142919444,
            -45.03316835934802,
            -21.02081282742367,
            -48.52285773274006,
            -53.47220699088999,
            -40.968342431463384,
            -18.09477167472851,
            -35.407796081342696,
            -31.186669991775172,
            -20.64545078967701,
            -25.74672998799987,
            -28.772775256963268,
            -34.32552459432447,
            -35.619133720517425,
            -25.913325625675093,
            -45.99934352796297,
            -54.72482262406024,
            -50.06955259218025,
            -39.637885456500165,
            -34.83792938827852,
            -30.264182058016605,
            -31.17984773181531,
            -38.648152855747306,
            -34.863171067938005,
            -43.34948588392681,
            -46.898713883589146,
            -34.984974469219445,
            -30.537840536388973,
            -42.4939096349759,
            -35.838761832249574,
            -43.91115805348044,
            -32.801453144186965,
            -25.467355417787115,
            -20.681046847759077,
            -34.13691740315631,
            -31.06212400695755,
            -38.54006237167198,
            -46.794498166259956,
            -25.71125389794818,
            -41.68316345169176,
            -37.467312933123694,
            -41.02873513456896,
            -37.42185771613684,
            -34.66156990239007,
            -28.474944508063565,
            -38.00085585301043,
            -28.094124053156822,
            -43.57963955536276,
            -43.31789425832413,
            -35.52662347337502,
            -42.11155968347807,
            -36.52393483117655,
            -37.44162727326797,
            -30.995433540886896,
            -34.13237468292977
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc9_std",
           "values": [
            0.9542774843253603,
            1.2531928436657565,
            1.4022149543673672,
            1.1088967723802583,
            1.1135983174474302,
            1.3656406894623294,
            1.2712032393368136,
            1.409901125528153,
            1.2835770884770363,
            0.8746257155811504,
            1.3822111746556036,
            1.1797339477825903,
            1.1407918018352443,
            0.6241742005033623,
            1.220192427835497,
            1.3392225728527762,
            0.7977765606585634,
            0.6891668946273215,
            0.908075226858152,
            1.1417282683522976,
            1.1231903708562978,
            1.139616067821367,
            1.0069899907273616,
            1.3020087688747584,
            1.2364574840627873,
            1.351063455458342,
            1.275175510275378,
            0.8911012917797572,
            1.2295058133195502,
            1.1429549669556431,
            1.4867065869837022,
            1.203947021633846,
            1.1106616502138165,
            1.2922847180879087,
            1.0694626853784797,
            1.0790479340677885,
            0.8601718643717237,
            0.6343383434199131,
            0.5851496671462312,
            0.9390843656515969,
            0.8545758931945413,
            0.7721772998183184,
            0.9698663177165039,
            0.9221556425228582,
            1.2029732956092405,
            1.2764326530435974,
            1.067106286393928,
            1.0698744186185476,
            1.110348631035621,
            1.1122856773370282,
            1.2121305757544645,
            1.2193756636768627,
            1.1510364042925285,
            1.074479028465264,
            0.9115801455349238,
            1.070172949392235,
            0.9197039316083049,
            1.0899047824506953,
            1.1447208479033533,
            1.2320071814047147,
            1.2204188662699726,
            1.3961740268627068,
            1.1239146823713395,
            1.0437009223919742,
            0.893712795484835,
            0.7643967407899629,
            1.096976863328776,
            1.2757595680923821,
            1.3137436009200396,
            1.4266322398400948,
            1.3322638251670305,
            1.1219432798565234,
            0.7983222286009004,
            1.1130337331603668,
            1.0414446703309748,
            0.9774714624942101,
            0.964050561679517,
            0.790465196146906,
            0.9221006704479969,
            1.298213777797164,
            1.2189455368881608,
            1.1351250339406511,
            1.1645147976587875,
            1.184172257564763,
            1.2900704421573825,
            1.1462389272750169,
            1.18735820044581,
            1.3355098891261707,
            1.495418654186921,
            1.7347119926722874,
            1.5852872497621968,
            0.8641087514150599,
            1.3519628782573991,
            1.0668652019688627,
            1.177080341854714,
            1.2064973264269538,
            1.38136114432615,
            1.334141853792705,
            1.0567323912409208,
            0.9025941045995324,
            1.0764865501444731,
            0.9849887430279691,
            1.0752390139107018,
            1.0974295229953006,
            1.1695382503791047,
            1.274202247572351,
            1.1582090642702403,
            1.194849785990345,
            0.9643428605027761,
            0.6151478342951443,
            1.139449783266275,
            1.1244037700032374,
            0.8652921705510913,
            0.8674235696925765,
            1.359800975240177,
            0.8597081661808558,
            0.8201849199101106,
            1.0306244170163583,
            1.0316038131192145,
            1.2087316293409363,
            1.1187603532637884,
            1.0236456098316356,
            1.225924726614301,
            1.177350732225837,
            1.2244259631287933,
            1.1918415650750684,
            0.9329098124137689,
            1.1449021639367785,
            1.2991586628679501,
            1.199917335264183,
            1.3527603229553569,
            1.3685775657590278,
            1.3582188362172802,
            1.4238650277513156,
            1.3446297910795393,
            1.3332868692407422,
            1.143103764601202,
            1.2983281272728644,
            1.4407246228788146,
            1.4414084351024097,
            1.284514793904301,
            1.3726449419836384,
            1.3350767165509492,
            1.3077544700758177,
            1.5783551428785014,
            1.2710889365133358,
            1.0768615088051872,
            1.0519233507180776,
            1.26773771873318,
            1.1619207890819891,
            1.7822401755174913,
            1.1287126422761518,
            1.2260570335579934,
            1.2316703436875618,
            1.580275161220786,
            1.26039190414586,
            1.232915521500604,
            1.1875015367313047,
            1.3223118588501104,
            1.1164272627734777,
            0.9833444740463894,
            1.2396947859525465,
            1.2716875937942034,
            1.1517118407036144,
            1.4377259066028416,
            1.5568019871547998,
            1.4345078453576807
           ]
          }
         ],
         "hovertemplate": "style=rock<br>%{xaxis.title.text}=%{x}<br>%{yaxis.title.text}=%{y}<extra></extra>",
         "legendgroup": "rock",
         "marker": {
          "color": "#00cc96",
          "symbol": "circle"
         },
         "name": "rock",
         "showlegend": true,
         "type": "splom"
        },
        {
         "dimensions": [
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc13_mean",
           "values": [
            -0.0020655211571137823,
            0.0013213314017344855,
            -0.009699977862349817,
            -0.018097861813274108,
            -0.015963150767660837,
            -0.005449367854093312,
            0.013884203607948915,
            -0.0027615966065940834,
            0.0010872817378655788,
            -0.007187992108296772,
            -0.0036415936184941936,
            -0.0007687715568168965,
            0.0012876724978946321,
            -0.0012197434304241244,
            -0.001220099117180483,
            -0.000841925639917878,
            -0.007189506950739308,
            -0.0060014555253494846,
            0.0015291538936345191,
            0.00004426942259382253,
            0.001808803193573878,
            0.0013233324519282086,
            -0.001011758561047443,
            -0.0009302701851394724,
            -0.0006111524924736765,
            -0.002092421745174631,
            -0.0007932019930652043,
            -0.0018184829799366864
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc13_std",
           "values": [
            6.7970351978354575,
            7.37081321856601,
            6.693864119069908,
            6.731104667788501,
            5.353952904388859,
            6.278979802930699,
            4.955160162044244,
            7.014478684883048,
            6.895518770167044,
            6.771317355455611,
            7.4465478979740265,
            7.396128627468117,
            7.6250047233065175,
            5.837107927973959,
            7.588485775780908,
            8.240386060579917,
            7.558857092330272,
            7.916279408144092,
            6.586688044233834,
            8.056986435039857,
            7.696799319381468,
            6.995469554497356,
            7.7879449733505055,
            8.23320844134169,
            6.863951551541046,
            7.952469882455305,
            7.7496131974759335,
            8.368007691155322
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "mfcc2_std",
           "values": [
            45.416578450870446,
            38.47367453928529,
            42.46109964176315,
            40.48124040637139,
            39.14729239484168,
            48.55888160050593,
            32.5321609947735,
            50.95677171061462,
            56.73489195659268,
            55.28460600569683,
            53.11093718910316,
            50.39158188576725,
            48.571546824775204,
            55.09140503543274,
            40.673640026046805,
            39.475483919360066,
            47.935792806973204,
            48.426917415298604,
            56.30742256876166,
            51.6876397995896,
            52.54238214558257,
            53.35499256643279,
            32.82479539769859,
            40.3102818025338,
            42.11999868093178,
            38.8094817544255,
            36.34171207763959,
            47.13739034007086
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc2_mean",
           "values": [
            0.006786948114063387,
            -0.005119739881298195,
            0.049278129474282874,
            -0.014585958869649033,
            0.009052144020381382,
            -0.0005068141756609842,
            0.058253686730692054,
            -0.022335677737030244,
            0.012705725548681294,
            -0.01249483726875187,
            -0.043935131259040354,
            0.0008910267214994339,
            0.06266045637284723,
            -0.07709664365412774,
            -0.0011618378750688375,
            0.0038149001423684677,
            0.11898716869237515,
            0.012838261944143853,
            0.04218008104712582,
            0.007514659217784565,
            0.021404134059188132,
            0.012055543917015632,
            -0.00457104829365595,
            -0.003906361661086944,
            -0.005612143040806213,
            -0.02118242061508916,
            0.000886012572037987,
            0.005338615901300373
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc3_std",
           "values": [
            3.4850659438240847,
            3.333030806813447,
            3.090639783111903,
            3.0205510706785446,
            3.167344590947017,
            4.122943436193243,
            2.9049858052843796,
            2.9879364971093136,
            3.105569351101354,
            3.101237391945358,
            2.9141754284316166,
            3.314201199657714,
            3.1732844761158274,
            2.978015954487969,
            2.4088472330447477,
            2.9075405067706224,
            2.4809171851093557,
            2.741472685988243,
            2.503020959638285,
            3.22254347778346,
            3.0880757856670553,
            2.5545770553913107,
            3.072815308248945,
            3.2708011454130403,
            2.8476553216069522,
            2.3373463980902542,
            2.389364009851066,
            2.9676176200465285
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc8_std",
           "values": [
            1.0983015721931533,
            1.1058976734339547,
            1.1418038048306132,
            1.058203163169663,
            0.9825862493237125,
            1.2449572755690526,
            1.0230117366503773,
            1.2269919400742513,
            1.0804902358830122,
            1.1601620486201072,
            1.1498675828832274,
            1.073029297791972,
            1.0604738853782347,
            0.9152962726845048,
            1.1357898165323608,
            1.358774981536638,
            1.329947096927292,
            1.1715187057074663,
            1.141133468523585,
            1.310905293892426,
            1.2824232109661042,
            1.1702270002775939,
            1.1942875687726011,
            1.047760196372133,
            0.8926228423861381,
            1.2281344494382398,
            1.1924018825055949,
            1.2077033436117801
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "rms_mean",
           "values": [
            -44.93428357077411,
            -48.58179690907093,
            -41.49888491995817,
            -42.85354531792905,
            -40.96467116754036,
            -33.695198691332045,
            -54.342037556552434,
            -37.279888860799595,
            -39.213442569749304,
            -34.825066760889705,
            -37.29301568149375,
            -44.327489105776685,
            -44.15322987439611,
            -48.91598448821551,
            -43.69085613689715,
            -42.35976789127336,
            -27.779944088788774,
            -35.25433429631543,
            -29.623949244848415,
            -43.1556208128775,
            -41.58150604944344,
            -35.556716075791776,
            -51.38348750537989,
            -50.71292269196957,
            -59.58624260180543,
            -36.03762586075037,
            -36.87585436305868,
            -40.66479156270014
           ]
          },
          {
           "axis": {
            "matches": true
           },
           "label": "delta_mfcc9_std",
           "values": [
            1.1393542855089902,
            1.0382708457770295,
            1.048135084173642,
            1.0318480958262954,
            1.021495323397951,
            1.3546984867035767,
            1.0085819764606947,
            1.228658172190335,
            1.186841778937544,
            1.286040730963121,
            1.2915365330263953,
            1.1550444959626007,
            1.1545937766257293,
            1.0673768236377177,
            1.2157841419229851,
            1.3055891711480263,
            1.488377372451078,
            1.269579928312192,
            1.0733481048051645,
            1.413474725179282,
            1.2655105609571633,
            1.1431801976276732,
            1.1419466461213317,
            1.1625436968724445,
            0.8834429920069863,
            1.32895578647819,
            1.206395504862034,
            1.192877230614071
           ]
          }
         ],
         "hovertemplate": "style=hiphop<br>%{xaxis.title.text}=%{x}<br>%{yaxis.title.text}=%{y}<extra></extra>",
         "legendgroup": "hiphop",
         "marker": {
          "color": "#ab63fa",
          "symbol": "circle"
         },
         "name": "hiphop",
         "showlegend": true,
         "type": "splom"
        }
       ],
       "layout": {
        "autosize": true,
        "dragmode": "select",
        "height": 1500,
        "legend": {
         "title": {
          "text": "style"
         },
         "tracegroupgap": 0
        },
        "margin": {
         "t": 60
        },
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "width": 1500
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import plotly.express as px\n",
    "lst=df.columns\n",
    "lst=['style','mfcc1_std', 'flux_mean', 'delta_mfcc1_std', 'flux_std', 'mfcc2_mean',\n",
    "       'mfcc9_mean', 'delta_mfcc10_std', 'zcr_std', 'mfcc13_mean',\n",
    "       'mfcc8_mean', 'delta_mfcc2_std', 'mfcc11_mean', 'centroid_std',\n",
    "       'mfcc10_mean', 'rms_std', 'centroid_mean', 'onsets_mid_std',\n",
    "       'delta_mfcc13_mean', 'mfcc13_std', 'mfcc2_std', 'delta_mfcc2_mean',\n",
    "       'delta_mfcc3_std', 'delta_mfcc8_std', 'rms_mean', 'delta_mfcc9_std']\n",
    "fig = px.scatter_matrix(df[lst],dimensions=['delta_mfcc13_mean', 'mfcc13_std', 'mfcc2_std', 'delta_mfcc2_mean',\n",
    "       'delta_mfcc3_std', 'delta_mfcc8_std', 'rms_mean', 'delta_mfcc9_std'],color='style')\n",
    "fig.update_layout(\n",
    "    autosize=True,\n",
    "    width=1500,\n",
    "    height=1500\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_allfeatures = df[['mfcc1_mean', 'mfcc2_mean', 'mfcc3_mean',\n",
    "       'mfcc4_mean', 'mfcc5_mean', 'mfcc6_mean', 'mfcc7_mean', 'mfcc8_mean',\n",
    "       'mfcc9_mean', 'mfcc10_mean', 'mfcc11_mean', 'mfcc12_mean',\n",
    "       'mfcc13_mean', 'mfcc1_std', 'mfcc2_std', 'mfcc3_std', 'mfcc4_std',\n",
    "       'mfcc5_std', 'mfcc6_std', 'mfcc7_std', 'mfcc8_std', 'mfcc9_std',\n",
    "       'mfcc10_std', 'mfcc11_std', 'mfcc12_std', 'mfcc13_std',\n",
    "       'delta_mfcc1_mean', 'delta_mfcc2_mean', 'delta_mfcc3_mean',\n",
    "       'delta_mfcc4_mean', 'delta_mfcc5_mean', 'delta_mfcc6_mean',\n",
    "       'delta_mfcc7_mean', 'delta_mfcc8_mean', 'delta_mfcc9_mean',\n",
    "       'delta_mfcc10_mean', 'delta_mfcc11_mean', 'delta_mfcc12_mean',\n",
    "       'delta_mfcc13_mean', 'delta_mfcc1_std', 'delta_mfcc2_std',\n",
    "       'delta_mfcc3_std', 'delta_mfcc4_std', 'delta_mfcc5_std',\n",
    "       'delta_mfcc6_std', 'delta_mfcc7_std', 'delta_mfcc8_std',\n",
    "       'delta_mfcc9_std', 'delta_mfcc10_std', 'delta_mfcc11_std',\n",
    "       'delta_mfcc12_std', 'delta_mfcc13_std',\\\n",
    "       'centroid_mean','centroid_std','rms_mean','rms_std','zcr_mean',\n",
    "       'zcr_std','crest_mean','crest_std','flux_mean','flux_std',\n",
    "       'onsets_mean', 'onsets_std','onsets_mid_mean', 'onsets_mid_std',\n",
    "       'onsets_high_mean', 'onsets_high_std']]\n",
    "\n",
    "y=df[['style']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['mfcc1_mean', 'mfcc2_mean', 'mfcc3_mean', 'mfcc4_mean', 'mfcc5_mean',\n",
      "       'mfcc6_mean', 'mfcc7_mean', 'mfcc8_mean', 'mfcc9_mean', 'mfcc10_mean',\n",
      "       'mfcc11_mean', 'mfcc12_mean', 'mfcc13_mean', 'mfcc1_std', 'mfcc2_std',\n",
      "       'mfcc3_std', 'mfcc4_std', 'mfcc5_std', 'mfcc6_std', 'mfcc7_std',\n",
      "       'mfcc8_std', 'mfcc9_std', 'mfcc10_std', 'mfcc11_std', 'mfcc12_std',\n",
      "       'mfcc13_std', 'delta_mfcc1_std', 'delta_mfcc2_std', 'centroid_mean',\n",
      "       'centroid_std', 'rms_mean', 'rms_std', 'onsets_mean', 'onsets_std'],\n",
      "      dtype='object')\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "#FEATURE SELECTION\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "selector = VarianceThreshold(threshold=0.5) # Variance threshold \n",
    "sel = selector.fit(X_allfeatures)\n",
    "sel_index = sel.get_support()\n",
    "X_vt = X_allfeatures.iloc[:, sel_index]\n",
    "print(X_vt.columns)\n",
    "print(len(X_vt.columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/sklearn/utils/validation.py:63: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mfcc1_std 0.19571416472480374\n",
      "flux_mean 0.18946082626843608\n",
      "delta_mfcc1_std 0.17146268280202936\n",
      "flux_std 0.1691835113249054\n",
      "mfcc2_mean 0.16391999508760668\n",
      "mfcc9_mean 0.1564266169681845\n",
      "delta_mfcc10_std 0.15125969257156835\n",
      "zcr_std 0.1498671756544192\n",
      "mfcc13_mean 0.14709893638139127\n",
      "mfcc8_mean 0.14374131132867474\n",
      "delta_mfcc2_std 0.14059785386746948\n",
      "mfcc11_mean 0.13268130431894432\n",
      "centroid_std 0.1267104351178172\n",
      "mfcc10_mean 0.12365698771666\n",
      "rms_std 0.12150884656847638\n",
      "centroid_mean 0.1196435291237734\n",
      "onsets_mid_std 0.1165737382301828\n",
      "delta_mfcc13_mean 0.11574028517528401\n",
      "mfcc13_std 0.11167288387253627\n",
      "mfcc2_std 0.11028943724045215\n",
      "delta_mfcc2_mean 0.10480984695020523\n",
      "delta_mfcc3_std 0.10225179505608484\n",
      "delta_mfcc8_std 0.09714559465137595\n",
      "rms_mean 0.09557731555876336\n",
      "delta_mfcc9_std 0.09517276092111637\n",
      "Index(['mfcc1_std', 'flux_mean', 'delta_mfcc1_std', 'flux_std', 'mfcc2_mean',\n",
      "       'mfcc9_mean', 'delta_mfcc10_std', 'zcr_std', 'mfcc13_mean',\n",
      "       'mfcc8_mean', 'delta_mfcc2_std', 'mfcc11_mean', 'centroid_std',\n",
      "       'mfcc10_mean', 'rms_std', 'centroid_mean', 'onsets_mid_std',\n",
      "       'delta_mfcc13_mean', 'mfcc13_std', 'mfcc2_std', 'delta_mfcc2_mean',\n",
      "       'delta_mfcc3_std', 'delta_mfcc8_std', 'rms_mean', 'delta_mfcc9_std'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import mutual_info_classif\n",
    "threshold = 25  # the number of most relevant features\n",
    "high_score_features = []\n",
    "feature_scores = mutual_info_classif(X_allfeatures, y, random_state=0)\n",
    "for score, f_name in sorted(zip(feature_scores, X_allfeatures.columns), reverse=True)[:threshold]:\n",
    "        print(f_name, score)\n",
    "        high_score_features.append(f_name)\n",
    "X_mic = X_allfeatures[high_score_features]\n",
    "print(X_mic.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "features=['mfcc1_std', 'flux_mean', 'delta_mfcc1_std', 'flux_std', 'mfcc2_mean',\n",
    "       'mfcc9_mean', 'delta_mfcc10_std', 'zcr_std', 'mfcc13_mean',\n",
    "       'mfcc8_mean', 'delta_mfcc2_std', 'mfcc11_mean', 'centroid_std',\n",
    "       'mfcc10_mean', 'rms_std', 'centroid_mean', 'onsets_mid_std',\n",
    "       'delta_mfcc13_mean', 'mfcc13_std', 'mfcc2_std', 'delta_mfcc2_mean',\n",
    "       'delta_mfcc3_std', 'delta_mfcc8_std', 'rms_mean', 'delta_mfcc9_std']\n",
    "X = df[features]\n",
    "y=df[['style']]\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=29)\n",
    "\n",
    "X_train = X_train.to_numpy()\n",
    "X_test = X_test.to_numpy()\n",
    "y_train = y_train.to_numpy()\n",
    "y_test = y_test.to_numpy()\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameter Optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for col in X.columns:\n",
    "    #df[col] = df[col]/max(np.abs(df[col]))\n",
    "    mean = np.mean(X[col])\n",
    "    std = np.std(X[col])\n",
    "    X[col] = (X[col] - mean)/std # z-score normalization\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_mic, y, test_size=0.33)\n",
    "X_train = X_train.to_numpy()\n",
    "X_test = X_test.to_numpy()\n",
    "y_train = y_train.to_numpy()\n",
    "y_test = y_test.to_numpy()\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "C = [x**0.01 for x in range(25,200)]\n",
    "kernel = ['rbf','linear','poly','sigmoid']\n",
    "degree = [int(x) for x in range(1,8)]\n",
    "gamma = ['scale','auto']\n",
    "coef0 = [x*0.1 for x in range(0,40)]\n",
    "decision_function_shape = ['ovo','ovr']\n",
    "svm_grid = { 'C' : C,\n",
    "            'kernel' : kernel,\n",
    "            'degree' : degree,\n",
    "            'gamma' : gamma,\n",
    "            'coef0' : coef0,\n",
    "            'decision_function_shape' : decision_function_shape\n",
    "            }\n",
    "svc = SVC()\n",
    "svm_df=pd.DataFrame()\n",
    "svm_df['trial']=[]\n",
    "svm_df['training_acc']=[]\n",
    "svm_df['accuracy'] = []\n",
    "svm_df['macro_accuracy'] = []\n",
    "svm_df['confusion_matrix']=[]\n",
    "svm_df['params']=[]\n",
    "svm_df['cv_acc']=[]\n",
    "svm_df['cv_std']=[]\n",
    "trial=[]\n",
    "training_acc = []\n",
    "accuracy=[]\n",
    "macro_accuracy=[]\n",
    "confusion=[]\n",
    "params=[]\n",
    "cv_acc=[]\n",
    "cv_std=[]\n",
    "for i in range(0,50):\n",
    "    trial.append(i)\n",
    "    #Optimize Hyperparameters\n",
    "    svc_RandomGrid = RandomizedSearchCV(estimator = svc, param_distributions=svm_grid,cv=10,verbose=0,n_jobs=4) #verbose=2\n",
    "    svc_RandomGrid.fit(X_train,y_train)\n",
    "    #print(f'Training CV Accuracy: {svc_RandomGrid.best_score_}')\n",
    "    training_acc.append(svc_RandomGrid.best_score_)\n",
    "    #print(svc_RandomGrid.best_params_)\n",
    "    params.append(svc_RandomGrid.best_params_)\n",
    "    #Predict based on hyperparameters that are optimized\n",
    "    y_prediction = svc_RandomGrid.predict(X_test)\n",
    "    #Calculate accuracy scores for testing\n",
    "    score=balanced_accuracy_score(y_test, y_prediction)\n",
    "    acc = accuracy_score(y_test, y_prediction)\n",
    "    cm = confusion_matrix(y_test, y_prediction) # clean, highfry, layered, lowfry, midfry, no vocals\n",
    "\n",
    "    accuracy.append(acc)\n",
    "    macro_accuracy.append(score)\n",
    "    confusion.append(cm)\n",
    "    # scores = cross_validate(svc_RandomGrid, X_train, y_train, cv=10)\n",
    "    # cv_acc.append(scores['test_score'].mean())\n",
    "    # cv_std.append(scores['test_score'].std())\n",
    "    # print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores['test_score'].mean(), scores['test_score'].std() * 2))\n",
    "    #print(f\"Confusion Matrix:\\n {cm}\")\n",
    "    #print(f\"Accuracy score: {accuracy}\")\n",
    "    #print(f\"Macro accuracy score: {score}\")\n",
    "\n",
    "\n",
    "svm_df['trial']= trial\n",
    "svm_df['cv_acc']=training_acc\n",
    "svm_df['accuracy'] = accuracy\n",
    "svm_df['macro_accuracy'] = macro_accuracy\n",
    "svm_df['confusion_matrix']=confusion\n",
    "svm_df['params']=params\n",
    "# svm_df['cv_acc']=cv_acc\n",
    "# svm_df['cv_std']=cv_std\n",
    "\n",
    "svm_df['macro_accuracy'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------------------\n",
      "            KNN             \n",
      "-------------------------------------------------------------------------------\n",
      "Confusion Matrix:\n",
      " [[ 6  1  0  2]\n",
      " [ 0  4  0  4]\n",
      " [ 0  1  1  6]\n",
      " [ 2  0  1 47]]\n",
      "[[0.66666667 0.125      0.         0.04      ]\n",
      " [0.         0.5        0.         0.08      ]\n",
      " [0.         0.125      0.125      0.12      ]\n",
      " [0.22222222 0.         0.125      0.94      ]]\n",
      "Accuracy score: 0.7733333333333333\n",
      "Macro accuracy score: 0.5579166666666666\n",
      "F1 score: 0.5849240613676663\n",
      "-------------------------------------------------------------------------------\n",
      "            SVM             \n",
      "-------------------------------------------------------------------------------\n",
      "[[ 6  0  0  3]\n",
      " [ 0  0  0  8]\n",
      " [ 0  0  6  2]\n",
      " [ 0  0  2 48]]\n",
      "[[0.66666667 0.         0.         0.06      ]\n",
      " [0.         0.         0.         0.16      ]\n",
      " [0.         0.         0.75       0.04      ]\n",
      " [0.         0.         0.25       0.96      ]]\n",
      "Accuracy Score:  0.8\n",
      "Macro accuracy Score: 0.5941666666666666\n",
      "F1 score: 0.6037162162162162\n",
      "-------------------------------------------------------------------------------\n",
      "            RF              \n",
      "-------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:179: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/utils/validation.py:63: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "\n",
      "<ipython-input-79-4e567a6bbaa9>:38: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6  0  0  3]\n",
      " [ 0  3  0  5]\n",
      " [ 0  0  5  3]\n",
      " [ 0  1  2 47]]\n",
      "[[0.66666667 0.         0.         0.06      ]\n",
      " [0.         0.375      0.         0.1       ]\n",
      " [0.         0.         0.625      0.06      ]\n",
      " [0.         0.125      0.25       0.94      ]]\n",
      "Accuracy Score:  0.8133333333333334\n",
      "Macro accuracy Score: 0.6516666666666666\n",
      "F1 score: 0.7092592592592593\n"
     ]
    }
   ],
   "source": [
    "print(\"-------------------------------------------------------------------------------\")\n",
    "print(\"            KNN             \")\n",
    "print(\"-------------------------------------------------------------------------------\")\n",
    "KNN_model = KNeighborsClassifier(n_neighbors=7)\n",
    "KNN_model.fit(X_train, y_train)\n",
    "KNN_prediction = KNN_model.predict(X_test)\n",
    "score=balanced_accuracy_score(y_test, KNN_prediction)\n",
    "accuracy = accuracy_score(y_test, KNN_prediction)\n",
    "f1=f1_score(y_test,KNN_prediction,average='macro')\n",
    "cm_knn = confusion_matrix(y_test, KNN_prediction) \n",
    "print(f\"Confusion Matrix:\\n {cm_knn}\")\n",
    "print(cm_knn/cm_knn.sum(axis=1))\n",
    "print(f\"Accuracy score: {accuracy}\")\n",
    "print(f\"Macro accuracy score: {score}\")\n",
    "print(f\"F1 score: {f1}\")\n",
    "\n",
    "print(\"-------------------------------------------------------------------------------\")\n",
    "print(\"            SVM             \")\n",
    "print(\"-------------------------------------------------------------------------------\")\n",
    "SVM_model = make_pipeline(StandardScaler(), SVC(kernel='poly',gamma='scale',degree=3,decision_function_shape='ovr',coef0=0.7000000000000001,C=1.053475672085955,random_state=0))\n",
    "SVM_model.fit(X_train, y_train)\n",
    "SVM_prediction = SVM_model.predict(X_test)\n",
    "score=balanced_accuracy_score(y_test, SVM_prediction)\n",
    "cm_svm = confusion_matrix(y_test, SVM_prediction) \n",
    "f1=f1_score(y_test,SVM_prediction,average='macro')\n",
    "acc = accuracy_score(y_test, SVM_prediction)\n",
    "print(cm_svm)\n",
    "print(cm_svm/cm_svm.sum(axis=1))\n",
    "print(\"Accuracy Score: \",acc)\n",
    "print(\"Macro accuracy Score:\",score)\n",
    "print(f\"F1 score: {f1}\")\n",
    "\n",
    "print(\"-------------------------------------------------------------------------------\")\n",
    "print(\"            RF              \")\n",
    "print(\"-------------------------------------------------------------------------------\")\n",
    "\n",
    "RF_model = RandomForestClassifier(n_estimators=800,min_samples_split = 8, min_samples_leaf = 2,max_leaf_nodes = 29, max_depth = 796, criterion = 'entropy',class_weight='balanced',random_state=0)\n",
    "RF_model.fit(X_train, y_train)\n",
    "# scores = cross_validate(RF_model, X_train, y_train, cv=10)\n",
    "RF_prediction = RF_model.predict(X_test)\n",
    "score=balanced_accuracy_score(y_test, RF_prediction)\n",
    "cm_rf = confusion_matrix(y_test, RF_prediction) \n",
    "f1=f1_score(y_test,RF_prediction,average='macro')\n",
    "acc = accuracy_score(y_test, RF_prediction)\n",
    "print(cm_rf)\n",
    "print(cm_rf/cm_rf.sum(axis=1))\n",
    "print(\"Accuracy Score: \",acc)\n",
    "print(\"Macro accuracy Score:\",score)\n",
    "print(f\"F1 score: {f1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n",
      "/usr/local/lib/python3.9/site-packages/sklearn/model_selection/_validation.py:598: DataConversionWarning:\n",
      "\n",
      "A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.70 (+/- 0.1573)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'fit_time': array([1.11058998, 1.21796393, 1.12736702, 1.11448216, 1.05590916,\n",
       "        1.40191913, 1.18972683, 1.21288204, 1.11625123, 1.12712789]),\n",
       " 'score_time': array([0.08088493, 0.08326197, 0.06420708, 0.08509707, 0.06427503,\n",
       "        0.10059977, 0.07270813, 0.06846189, 0.06622791, 0.08391595]),\n",
       " 'test_score': array([0.66666667, 0.61111111, 0.58823529, 0.64705882, 0.82352941,\n",
       "        0.76470588, 0.82352941, 0.70588235, 0.70588235, 0.64705882])}"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores = cross_validate(RF_model, X_train, y_train, cv=10)\n",
    "# print(scores['test_score'].mean())\n",
    "# print(scores['test_score'].std())\n",
    "print(\"Accuracy: %0.2f (+/- %0.4f)\" % (scores['test_score'].mean(), scores['test_score'].std() * 2))\n",
    "# print(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import ConfusionMatrixDisplay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['funk', 'hiphop', 'jazz', 'rock'], dtype=object)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RF_model.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66666667, 0.        , 0.        , 0.06      ],\n",
       "       [0.        , 0.375     , 0.        , 0.1       ],\n",
       "       [0.        , 0.        , 0.625     , 0.06      ],\n",
       "       [0.        , 0.125     , 0.25      , 0.94      ]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_rf/cm_rf.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66666667, 0.        , 0.        , 0.06      ],\n",
       "       [0.        , 0.        , 0.        , 0.16      ],\n",
       "       [0.        , 0.        , 0.75      , 0.04      ],\n",
       "       [0.        , 0.        , 0.25      , 0.96      ]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_svm/cm_svm.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66666667, 0.125     , 0.        , 0.04      ],\n",
       "       [0.        , 0.5       , 0.        , 0.08      ],\n",
       "       [0.        , 0.125     , 0.125     , 0.12      ],\n",
       "       [0.22222222, 0.        , 0.125     , 0.94      ]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_knn/cm_knn.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "alignmentgroup": "True",
         "hovertemplate": "variable=kNN<br>index=%{x}<br>value=%{y}<extra></extra>",
         "legendgroup": "kNN",
         "marker": {
          "color": "#636efa"
         },
         "name": "kNN",
         "offsetgroup": "kNN",
         "orientation": "v",
         "showlegend": true,
         "textposition": "auto",
         "type": "bar",
         "x": [
          "funk",
          "hiphop",
          "jazz",
          "rock"
         ],
         "xaxis": "x",
         "y": [
          0.6666,
          0.5,
          0.125,
          0.94
         ],
         "yaxis": "y"
        },
        {
         "alignmentgroup": "True",
         "hovertemplate": "variable=Random Forest<br>index=%{x}<br>value=%{y}<extra></extra>",
         "legendgroup": "Random Forest",
         "marker": {
          "color": "#EF553B"
         },
         "name": "Random Forest",
         "offsetgroup": "Random Forest",
         "orientation": "v",
         "showlegend": true,
         "textposition": "auto",
         "type": "bar",
         "x": [
          "funk",
          "hiphop",
          "jazz",
          "rock"
         ],
         "xaxis": "x",
         "y": [
          0.6666,
          0.375,
          0.625,
          0.94
         ],
         "yaxis": "y"
        },
        {
         "alignmentgroup": "True",
         "hovertemplate": "variable=SVM<br>index=%{x}<br>value=%{y}<extra></extra>",
         "legendgroup": "SVM",
         "marker": {
          "color": "#00cc96"
         },
         "name": "SVM",
         "offsetgroup": "SVM",
         "orientation": "v",
         "showlegend": true,
         "textposition": "auto",
         "type": "bar",
         "x": [
          "funk",
          "hiphop",
          "jazz",
          "rock"
         ],
         "xaxis": "x",
         "y": [
          0.6666,
          0,
          0.75,
          0.96
         ],
         "yaxis": "y"
        }
       ],
       "layout": {
        "autosize": true,
        "barmode": "group",
        "font": {
         "size": 28
        },
        "height": 800,
        "legend": {
         "orientation": "h",
         "title": {
          "text": ""
         },
         "tracegroupgap": 0,
         "x": 0.5,
         "xanchor": "center",
         "y": -0.2,
         "yanchor": "top"
        },
        "margin": {
         "b": 100,
         "l": 50,
         "pad": 0,
         "r": 50,
         "t": 100
        },
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "title": {
         "text": "Classwise accuracies",
         "x": 0.5,
         "xanchor": "center",
         "y": 0.95,
         "yanchor": "top"
        },
        "width": 1200,
        "xaxis": {
         "anchor": "y",
         "automargin": true,
         "domain": [
          0,
          1
         ],
         "tickangle": -19,
         "title": {
          "font": {
           "size": 1
          },
          "standoff": 0,
          "text": ""
         }
        },
        "yaxis": {
         "anchor": "x",
         "domain": [
          0,
          1
         ],
         "tickangle": 0,
         "tickformat": ",.0%",
         "title": {
          "font": {
           "size": 36
          },
          "standoff": 50,
          "text": "Accuracy"
         }
        }
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "classes=KNN_model.classes_\n",
    "knn_classwise=np.array([0.6666,0.5,0.125,0.94])\n",
    "rf_classwise = np.array([0.6666,0.375,0.625,0.94])\n",
    "svm_classwise = np.array([0.6666,0,0.75,0.96])\n",
    "# fcnn_classwise = np.array([.6271,.5357,.1935,.0298,.3333,.8108])\n",
    "# cnn_classwise = np.array([0.8953,0.8127,0.9180])\n",
    "\n",
    "df=pd.DataFrame()\n",
    "\n",
    "df['kNN']=knn_classwise\n",
    "df['Random Forest'] = rf_classwise\n",
    "df['SVM'] = svm_classwise\n",
    "# df['Fully Connected Network'] = fcnn_classwise\n",
    "# df['CNN'] = cnn_classwise\n",
    "\n",
    "df=df.T\n",
    "df.columns=classes\n",
    "df=df.T\n",
    "\n",
    "import plotly.express as px\n",
    "fig=px.bar(df,x=df.index,y=['kNN','Random Forest','SVM'],barmode='group')\n",
    "fig.update_layout(\n",
    "    autosize=True,\n",
    "    width=1200,\n",
    "    height=800,\n",
    "    title={\n",
    "        'text': \"Classwise accuracies\",\n",
    "        'x':0.5,\n",
    "        'y':0.95,\n",
    "        'xanchor': 'center',\n",
    "        'yanchor': 'top',\n",
    "        },\n",
    "    font=dict(\n",
    "        size=28\n",
    "    ),\n",
    "    margin=dict(\n",
    "        l=50,\n",
    "        r=50,\n",
    "        b=100,\n",
    "        t=100,\n",
    "        pad=0\n",
    "    ),\n",
    "    legend=dict(\n",
    "    orientation=\"h\",\n",
    "    yanchor=\"top\",\n",
    "    y=-0.2,\n",
    "    xanchor=\"center\",\n",
    "    x=0.5\n",
    "\n",
    ")\n",
    "    )\n",
    "fig.update_xaxes(\n",
    "        tickangle = -19,\n",
    "        title_text = \"\",\n",
    "        title_font = {\"size\": 1},\n",
    "        title_standoff = 0)\n",
    "fig.update_yaxes(\n",
    "        tickangle = 0,\n",
    "        title_text = \"Accuracy\",\n",
    "        title_font = {\"size\": 36},\n",
    "        title_standoff = 50)\n",
    "fig.update_layout(legend_title_text='')\n",
    "fig.update_layout(yaxis= { 'tickformat': ',.0%'})\n",
    "fig.update_xaxes(automargin=True)\n",
    "fig.write_image(\"/Users/vedant/Desktop/Programming/ACA-project/classwise-accuracies.jpg\", format=\"jpg\", width=1200, height=800, scale=2)\n",
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "l=KNN_model.classes_\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm_knn/cm_knn.sum(axis=1),display_labels=l)\n",
    "disp.plot(xticks_rotation=45)\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(10, 9)\n",
    "plt.tight_layout()\n",
    "plt.title(\"Confusion Matrix for kNN classifier\",fontsize=20)\n",
    "plt.savefig('/Users/vedant/Desktop/Programming/ACA-project/knn_cm.jpg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9,  8,  8, 50])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_svm.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 0, 0, 3])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_svm[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm_svm[0].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66666667, 0.11111111, 0.        , 0.22222222],\n",
       "       [0.        , 0.5       , 0.        , 0.5       ],\n",
       "       [0.        , 0.125     , 0.125     , 0.75      ],\n",
       "       [0.04      , 0.        , 0.02      , 0.94      ]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.zeros([4,4])\n",
    "for i in range(cm_knn.shape[0]):\n",
    "    c[i] = cm_knn[i]/cm_knn[i].sum()\n",
    "\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "l=SVM_model.classes_\n",
    "disp = ConfusionMatrixDisplay(c,display_labels=l)\n",
    "disp.plot(xticks_rotation=45)\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(10, 9)\n",
    "plt.tight_layout()\n",
    "plt.title(\"Confusion Matrix for KNN classifier\",fontsize=20)\n",
    "plt.savefig('/Users/vedant/Desktop/Programming/ACA-project/knn_cm.jpg')"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}