pd_classification_voice_with_feature_selection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:19.638585Z",
     "iopub.status.busy": "2023-10-10T10:21:19.637773Z",
     "iopub.status.idle": "2023-10-10T10:21:32.610712Z",
     "shell.execute_reply": "2023-10-10T10:21:32.609165Z"
    },
    "id": "5aFa_0cYBEoB",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import parselmouth\n",
    "import librosa\n",
    "\n",
    "from parselmouth.praat import call\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:32.619999Z",
     "iopub.status.busy": "2023-10-10T10:21:32.619496Z",
     "iopub.status.idle": "2023-10-10T10:21:37.669084Z",
     "shell.execute_reply": "2023-10-10T10:21:37.667302Z"
    }
   },
   "outputs": [],
   "source": [
    "from pyrpde import rpde\n",
    "from pydub import AudioSegment\n",
    "import speech_recognition as sr\n",
    "import io"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:37.676200Z",
     "iopub.status.busy": "2023-10-10T10:21:37.675714Z",
     "iopub.status.idle": "2023-10-10T10:21:37.682048Z",
     "shell.execute_reply": "2023-10-10T10:21:37.680708Z"
    },
    "id": "Os4OH4A1SzU_"
   },
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:37.687978Z",
     "iopub.status.busy": "2023-10-10T10:21:37.687528Z",
     "iopub.status.idle": "2023-10-10T10:21:38.548578Z",
     "shell.execute_reply": "2023-10-10T10:21:38.546730Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# author: Dominik Krzeminski (dokato)\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.signal as ss\n",
    "\n",
    "# detrended fluctuation analysis\n",
    "\n",
    "def calc_rms(x, scale):\n",
    "    \"\"\"\n",
    "    windowed Root Mean Square (RMS) with linear detrending.\n",
    "\n",
    "    Args:\n",
    "    -----\n",
    "      *x* : numpy.array\n",
    "        one dimensional data vector\n",
    "      *scale* : int\n",
    "        length of the window in which RMS will be calculaed\n",
    "    Returns:\n",
    "    --------\n",
    "      *rms* : numpy.array\n",
    "        RMS data in each window with length len(x)//scale\n",
    "    \"\"\"\n",
    "    # making an array with data divided in windows\n",
    "    shape = (x.shape[0]//scale, scale)\n",
    "    X = np.lib.stride_tricks.as_strided(x,shape=shape)\n",
    "    # vector of x-axis points to regression\n",
    "    scale_ax = np.arange(scale)\n",
    "    rms = np.zeros(X.shape[0])\n",
    "    for e, xcut in enumerate(X):\n",
    "        coeff = np.polyfit(scale_ax, xcut, 1)\n",
    "        xfit = np.polyval(coeff, scale_ax)\n",
    "        # detrending and computing RMS of each window\n",
    "        rms[e] = np.sqrt(np.mean((xcut-xfit)**2))\n",
    "    return rms\n",
    "\n",
    "def dfa(x, scale_lim=[5,9], scale_dens=0.25, show=False):\n",
    "    \"\"\"\n",
    "    Detrended Fluctuation Analysis - measures power law scaling coefficient\n",
    "    of the given signal *x*.\n",
    "\n",
    "    More details about the algorithm you can find e.g. here:\n",
    "    Hardstone, R. et al. Detrended fluctuation analysis: A scale-free\n",
    "    view on neuronal oscillations, (2012).\n",
    "\n",
    "    Args:\n",
    "    -----\n",
    "      *x* : numpy.array\n",
    "        one dimensional data vector\n",
    "      *scale_lim* = [5,9] : list of length 2\n",
    "        boundaries of the scale, where scale means windows among which RMS\n",
    "        is calculated. Numbers from list are exponents of 2 to the power\n",
    "        of X, eg. [5,9] is in fact [2**5, 2**9].\n",
    "        You can think of it that if your signal is sampled with F_s = 128 Hz,\n",
    "        then the lowest considered scale would be 2**5/128 = 32/128 = 0.25,\n",
    "        so 250 ms.\n",
    "      *scale_dens* = 0.25 : float\n",
    "        density of scale divisions, eg. for 0.25 we get 2**[5, 5.25, 5.5, ... ]\n",
    "      *show* = False\n",
    "        if True it shows matplotlib log-log plot.\n",
    "    Returns:\n",
    "    --------\n",
    "      *scales* : numpy.array\n",
    "        vector of scales (x axis)\n",
    "      *fluct* : numpy.array\n",
    "        fluctuation function values (y axis)\n",
    "      *alpha* : float\n",
    "        estimation of DFA exponent\n",
    "    \"\"\"\n",
    "    # cumulative sum of data with substracted offset\n",
    "    y = np.cumsum(x - np.mean(x))\n",
    "    scales = (2**np.arange(scale_lim[0], scale_lim[1], scale_dens)).astype(np.int)\n",
    "    fluct = np.zeros(len(scales))\n",
    "    # computing RMS for each window\n",
    "    for e, sc in enumerate(scales):\n",
    "        fluct[e] = np.sqrt(np.mean(calc_rms(y, sc)**2))\n",
    "    # fitting a line to rms data\n",
    "    coeff = np.polyfit(np.log2(scales), np.log2(fluct), 1)\n",
    "    if show:\n",
    "        fluctfit = 2**np.polyval(coeff,np.log2(scales))\n",
    "        plt.loglog(scales, fluct, 'bo')\n",
    "        plt.loglog(scales, fluctfit, 'r', label=r'$\\alpha$ = %0.2f'%coeff[0])\n",
    "        plt.title('DFA')\n",
    "        plt.xlabel(r'$\\log_{10}$(time window)')\n",
    "        plt.ylabel(r'$\\log_{10}$<F(t)>')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "    return scales, fluct, coeff[0]\n",
    "\n",
    "\n",
    "if __name__=='__main__':\n",
    "    n = 1000\n",
    "    x = np.random.randn(n)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# # Using code modified from https://github.com/drfeinberg/PraatScripts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.557512Z",
     "iopub.status.busy": "2023-10-10T10:21:38.556928Z",
     "iopub.status.idle": "2023-10-10T10:21:38.572283Z",
     "shell.execute_reply": "2023-10-10T10:21:38.570905Z"
    },
    "id": "atRD1MPoSBfl"
   },
   "outputs": [],
   "source": [
    "# This is the function to measure voice pitch\n",
    "def measurePitch(voiceID, f0min, f0max, unit):\n",
    "    sound = parselmouth.Sound(voiceID) # read the sound\n",
    "    pitch = call(sound, \"To Pitch\", 0.0, f0min, f0max) #create a praat pitch object\n",
    "    meanF0 = call(pitch, \"Get mean\", 0, 0, unit) # get mean pitch\n",
    "    stdevF0 = call(pitch, \"Get standard deviation\", 0 ,0, unit) # get standard deviation\n",
    "    harmonicity = call(sound, \"To Harmonicity (cc)\", 0.01, 75, 0.1, 1.0)\n",
    "    hnr = call(harmonicity, \"Get mean\", 0, 0)\n",
    "    pointProcess = call(sound, \"To PointProcess (periodic, cc)\", f0min, f0max)\n",
    "    localJitter = call(pointProcess, \"Get jitter (local)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    localabsoluteJitter = call(pointProcess, \"Get jitter (local, absolute)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    rapJitter = call(pointProcess, \"Get jitter (rap)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    ppq5Jitter = call(pointProcess, \"Get jitter (ppq5)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    ddpJitter = call(pointProcess, \"Get jitter (ddp)\", 0, 0, 0.0001, 0.02, 1.3)\n",
    "    localShimmer =  call([sound, pointProcess], \"Get shimmer (local)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    localdbShimmer = call([sound, pointProcess], \"Get shimmer (local_dB)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    apq3Shimmer = call([sound, pointProcess], \"Get shimmer (apq3)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    aqpq5Shimmer = call([sound, pointProcess], \"Get shimmer (apq5)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    apq11Shimmer =  call([sound, pointProcess], \"Get shimmer (apq11)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "    ddaShimmer = call([sound, pointProcess], \"Get shimmer (dda)\", 0, 0, 0.0001, 0.02, 1.3, 1.6)\n",
    "\n",
    "\n",
    "    return meanF0, stdevF0, hnr, localJitter, localabsoluteJitter, rapJitter, ppq5Jitter, ddpJitter, localShimmer, localdbShimmer, apq3Shimmer, aqpq5Shimmer, apq11Shimmer, ddaShimmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.579337Z",
     "iopub.status.busy": "2023-10-10T10:21:38.578876Z",
     "iopub.status.idle": "2023-10-10T10:21:38.586759Z",
     "shell.execute_reply": "2023-10-10T10:21:38.585275Z"
    }
   },
   "outputs": [],
   "source": [
    "def featuresVoiceNonTraditional(y):\n",
    "    entropy, histogram = rpde(y, dim=4, tau=35, epsilon = 0.12, tmax = 1500)\n",
    "    scales, fluct, alpha = dfa(y,show=False)\n",
    "    return entropy, alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.591579Z",
     "iopub.status.busy": "2023-10-10T10:21:38.591075Z",
     "iopub.status.idle": "2023-10-10T10:21:38.599108Z",
     "shell.execute_reply": "2023-10-10T10:21:38.597642Z"
    }
   },
   "outputs": [],
   "source": [
    "def audiosegment_to_librosawav(audiosegment):\n",
    "    samples = [audiosegment.get_array_of_samples()]\n",
    "    \n",
    "    fp_arr = np.array(samples).T.astype(np.float32)\n",
    "    fp_arr /= np.iinfo(samples[0].typecode).max\n",
    "    fp_arr = fp_arr.reshape(-1)\n",
    "    \n",
    "    return fp_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.603916Z",
     "iopub.status.busy": "2023-10-10T10:21:38.603410Z",
     "iopub.status.idle": "2023-10-10T10:21:38.621561Z",
     "shell.execute_reply": "2023-10-10T10:21:38.620147Z"
    },
    "id": "v6HPtpk9uNeN"
   },
   "outputs": [],
   "source": [
    "def create_voice_df_pd(path, csv_name):\n",
    "\n",
    "  file_list = []\n",
    "  mean_F0_list = []\n",
    "  sd_F0_list = []\n",
    "  hnr_list = []\n",
    "  localJitter_list = []\n",
    "  localabsoluteJitter_list = []\n",
    "  rapJitter_list = []\n",
    "  ppq5Jitter_list = []\n",
    "  ddpJitter_list = []\n",
    "  localShimmer_list = []\n",
    "  localdbShimmer_list = []\n",
    "  apq3Shimmer_list = []\n",
    "  aqpq5Shimmer_list = []\n",
    "  apq11Shimmer_list = []\n",
    "  ddaShimmer_list = []\n",
    "  rpde_list = []\n",
    "  dfa_list = []\n",
    "  class_list = []\n",
    "\n",
    "  for wave_file in glob.glob(path):\n",
    "      sound = parselmouth.Sound(wave_file)\n",
    "      y = AudioSegment.from_wav(wave_file)\n",
    "      y = audiosegment_to_librosawav(y)\n",
    "      entropy, alpha = featuresVoiceNonTraditional(y)\n",
    "      (meanF0, stdevF0, hnr, localJitter, localabsoluteJitter,\n",
    "      rapJitter, ppq5Jitter, ddpJitter, localShimmer, localdbShimmer,\n",
    "      apq3Shimmer, aqpq5Shimmer, apq11Shimmer, ddaShimmer) = measurePitch(sound, 75, 500, \"Hertz\")\n",
    "      file_list.append(wave_file)\n",
    "      class_list.append(1)\n",
    "      mean_F0_list.append(meanF0) # make a mean F0 list\n",
    "      sd_F0_list.append(stdevF0) # make a sd F0 list\n",
    "      hnr_list.append(hnr)\n",
    "      localJitter_list.append(localJitter)\n",
    "      localabsoluteJitter_list.append(localabsoluteJitter)\n",
    "      rapJitter_list.append(rapJitter)\n",
    "      ppq5Jitter_list.append(ppq5Jitter)\n",
    "      ddpJitter_list.append(ddpJitter)\n",
    "      localShimmer_list.append(localShimmer)\n",
    "      localdbShimmer_list.append(localdbShimmer)\n",
    "      apq3Shimmer_list.append(apq3Shimmer)\n",
    "      aqpq5Shimmer_list.append(aqpq5Shimmer)\n",
    "      apq11Shimmer_list.append(apq11Shimmer)\n",
    "      ddaShimmer_list.append(ddaShimmer)\n",
    "      rpde_list.append(entropy)\n",
    "      dfa_list.append(alpha)\n",
    "\n",
    "\n",
    "  col = ['voiceName','class','meanF0Hz', 'stdevF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA']\n",
    "\n",
    "  col_float = ['class','meanF0Hz', 'stdevF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA']\n",
    "\n",
    "\n",
    "  df = pd.DataFrame(np.column_stack([file_list, class_list, mean_F0_list, sd_F0_list, hnr_list, localJitter_list,\n",
    "                                   localabsoluteJitter_list, rapJitter_list, ppq5Jitter_list, ddpJitter_list,\n",
    "                                   localShimmer_list, localdbShimmer_list, apq3Shimmer_list, aqpq5Shimmer_list,\n",
    "                                   apq11Shimmer_list, ddaShimmer_list, rpde_list, dfa_list]),\n",
    "                               columns= col)  #add these lists to pandas in the right order\n",
    "\n",
    "  for column in col_float:\n",
    "    df[column] = df[column].astype(float)\n",
    "\n",
    "  # Write out the updated dataframe\n",
    "  df.to_csv(csv_name, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.626855Z",
     "iopub.status.busy": "2023-10-10T10:21:38.626354Z",
     "iopub.status.idle": "2023-10-10T10:21:38.643719Z",
     "shell.execute_reply": "2023-10-10T10:21:38.642298Z"
    },
    "id": "aAY24NaU82g4"
   },
   "outputs": [],
   "source": [
    "def create_voice_df_control(path, csv_name):\n",
    "\n",
    "  file_list = []\n",
    "  mean_F0_list = []\n",
    "  sd_F0_list = []\n",
    "  hnr_list = []\n",
    "  localJitter_list = []\n",
    "  localabsoluteJitter_list = []\n",
    "  rapJitter_list = []\n",
    "  ppq5Jitter_list = []\n",
    "  ddpJitter_list = []\n",
    "  localShimmer_list = []\n",
    "  localdbShimmer_list = []\n",
    "  apq3Shimmer_list = []\n",
    "  aqpq5Shimmer_list = []\n",
    "  apq11Shimmer_list = []\n",
    "  ddaShimmer_list = []\n",
    "  rpde_list = []\n",
    "  dfa_list = []\n",
    "  class_list = []\n",
    "\n",
    "  for wave_file in glob.glob(path):\n",
    "      sound = parselmouth.Sound(wave_file)\n",
    "      y = AudioSegment.from_wav(wave_file)\n",
    "      y = audiosegment_to_librosawav(y)\n",
    "      entropy, alpha = featuresVoiceNonTraditional(y)\n",
    "      (meanF0, stdevF0, hnr, localJitter, localabsoluteJitter,\n",
    "      rapJitter, ppq5Jitter, ddpJitter, localShimmer, localdbShimmer,\n",
    "      apq3Shimmer, aqpq5Shimmer, apq11Shimmer, ddaShimmer) = measurePitch(sound, 75, 500, \"Hertz\")\n",
    "      file_list.append(wave_file)\n",
    "      class_list.append(0)\n",
    "      mean_F0_list.append(meanF0) # make a mean F0 list\n",
    "      sd_F0_list.append(stdevF0) # make a sd F0 list\n",
    "      hnr_list.append(hnr)\n",
    "      localJitter_list.append(localJitter)\n",
    "      localabsoluteJitter_list.append(localabsoluteJitter)\n",
    "      rapJitter_list.append(rapJitter)\n",
    "      ppq5Jitter_list.append(ppq5Jitter)\n",
    "      ddpJitter_list.append(ddpJitter)\n",
    "      localShimmer_list.append(localShimmer)\n",
    "      localdbShimmer_list.append(localdbShimmer)\n",
    "      apq3Shimmer_list.append(apq3Shimmer)\n",
    "      aqpq5Shimmer_list.append(aqpq5Shimmer)\n",
    "      apq11Shimmer_list.append(apq11Shimmer)\n",
    "      ddaShimmer_list.append(ddaShimmer)\n",
    "      rpde_list.append(entropy)\n",
    "      dfa_list.append(alpha)\n",
    "\n",
    "\n",
    "  col = ['voiceName','class','meanF0Hz', 'stdevF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA']\n",
    "\n",
    "  col_float = ['class','meanF0Hz', 'stdevF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA']\n",
    "\n",
    "\n",
    "  df = pd.DataFrame(np.column_stack([file_list, class_list, mean_F0_list, sd_F0_list, hnr_list, localJitter_list,\n",
    "                                   localabsoluteJitter_list, rapJitter_list, ppq5Jitter_list, ddpJitter_list,\n",
    "                                   localShimmer_list, localdbShimmer_list, apq3Shimmer_list, aqpq5Shimmer_list,\n",
    "                                   apq11Shimmer_list, ddaShimmer_list, rpde_list, dfa_list]),\n",
    "                               columns= col)  #add these lists to pandas in the right order\n",
    "\n",
    "\n",
    "  for column in col_float:\n",
    "    df[column] = df[column].astype(float)\n",
    "\n",
    "  # Write out the updated dataframe\n",
    "  df.to_csv(csv_name, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9VfIp9VgoXXh"
   },
   "source": [
    "#Import Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.650076Z",
     "iopub.status.busy": "2023-10-10T10:21:38.649546Z",
     "iopub.status.idle": "2023-10-10T10:21:38.660746Z",
     "shell.execute_reply": "2023-10-10T10:21:38.659181Z"
    }
   },
   "outputs": [],
   "source": [
    "def create_csv(directory):\n",
    "    if 'Dataset1' in directory:\n",
    "        for folder in os.listdir(directory):\n",
    "            if 'Control' in folder:\n",
    "                create_voice_df_control(directory + folder + '/*.wav', f'{folder.lower()}.csv')\n",
    "            if 'PD' in folder:\n",
    "                create_voice_df_pd(directory + folder + '/*.wav', f'{folder.lower()}.csv')\n",
    "            \n",
    "    if 'Dataset2' in directory:\n",
    "        for folder in os.listdir(directory):\n",
    "            if 'Control' in folder:\n",
    "                create_voice_df_control(directory + folder + '/*.wav', f'dataset2_{folder.lower()}.csv')\n",
    "            if 'PD' in folder:\n",
    "                create_voice_df_pd(directory + folder + '/*.wav', f'dataset2_{folder.lower()}.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.666184Z",
     "iopub.status.busy": "2023-10-10T10:21:38.665703Z",
     "iopub.status.idle": "2023-10-10T10:21:38.671740Z",
     "shell.execute_reply": "2023-10-10T10:21:38.670269Z"
    }
   },
   "outputs": [],
   "source": [
    "#create_csv('DATASET_FULL/Dataset1_half_toserver/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.676587Z",
     "iopub.status.busy": "2023-10-10T10:21:38.676098Z",
     "iopub.status.idle": "2023-10-10T10:21:38.682198Z",
     "shell.execute_reply": "2023-10-10T10:21:38.680697Z"
    }
   },
   "outputs": [],
   "source": [
    "#create_csv('DATASET_FULL/Dataset2_half_toserver/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.686643Z",
     "iopub.status.busy": "2023-10-10T10:21:38.686173Z",
     "iopub.status.idle": "2023-10-10T10:21:38.757376Z",
     "shell.execute_reply": "2023-10-10T10:21:38.756027Z"
    },
    "id": "tVuR4RR5kerb"
   },
   "outputs": [],
   "source": [
    "df_pd_01 = pd.read_csv('pd_01.csv')\n",
    "df_pd_02 = pd.read_csv('pd_02.csv')\n",
    "df_pd_03 = pd.read_csv('pd_03.csv')\n",
    "df_pd_04 = pd.read_csv('pd_04.csv')\n",
    "df_pd_05 = pd.read_csv('pd_05.csv')\n",
    "df_pd_06 = pd.read_csv('pd_06.csv')\n",
    "df_pd_07 = pd.read_csv('pd_07.csv')\n",
    "df_pd_08 = pd.read_csv('pd_08.csv')\n",
    "df_pd_09 = pd.read_csv('pd_09.csv')\n",
    "df_pd_10 = pd.read_csv('pd_10.csv')\n",
    "df_pd_11 = pd.read_csv('pd_11.csv')\n",
    "df_pd_12 = pd.read_csv('pd_12.csv')\n",
    "df_pd_13 = pd.read_csv('pd_13.csv')\n",
    "df_pd_14 = pd.read_csv('pd_14.csv')\n",
    "df_pd_15 = pd.read_csv('pd_15.csv')\n",
    "df_pd_16 = pd.read_csv('pd_16.csv')\n",
    "df_pd_17 = pd.read_csv('pd_17.csv')\n",
    "df_pd_18 = pd.read_csv('pd_18.csv')\n",
    "df_pd_19 = pd.read_csv('pd_19.csv')\n",
    "df_pd_20 = pd.read_csv('pd_20.csv')\n",
    "df_pd_21 = pd.read_csv('pd_21.csv')\n",
    "df_pd_22 = pd.read_csv('pd_22.csv')\n",
    "df_pd_23 = pd.read_csv('pd_23.csv')\n",
    "df_pd_24 = pd.read_csv('pd_24.csv')\n",
    "df_pd_25 = pd.read_csv('pd_25.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.763972Z",
     "iopub.status.busy": "2023-10-10T10:21:38.763457Z",
     "iopub.status.idle": "2023-10-10T10:21:38.825249Z",
     "shell.execute_reply": "2023-10-10T10:21:38.823911Z"
    },
    "id": "93pntq_YKjPc"
   },
   "outputs": [],
   "source": [
    "df_control_01 = pd.read_csv('control_01.csv')\n",
    "df_control_02 = pd.read_csv('control_02.csv')\n",
    "df_control_03 = pd.read_csv('control_03.csv')\n",
    "df_control_04 = pd.read_csv('control_04.csv')\n",
    "df_control_05 = pd.read_csv('control_05.csv')\n",
    "df_control_06 = pd.read_csv('control_06.csv')\n",
    "df_control_07 = pd.read_csv('control_07.csv')\n",
    "df_control_08 = pd.read_csv('control_08.csv')\n",
    "df_control_09 = pd.read_csv('control_09.csv')\n",
    "df_control_10 = pd.read_csv('control_10.csv')\n",
    "df_control_11 = pd.read_csv('control_11.csv')\n",
    "df_control_12 = pd.read_csv('control_12.csv')\n",
    "df_control_13 = pd.read_csv('control_13.csv')\n",
    "df_control_15 = pd.read_csv('control_15.csv')\n",
    "df_control_16 = pd.read_csv('control_16.csv')\n",
    "df_control_17 = pd.read_csv('control_17.csv')\n",
    "df_control_18 = pd.read_csv('control_18.csv')\n",
    "df_control_19 = pd.read_csv('control_19.csv')\n",
    "df_control_20 = pd.read_csv('control_20.csv')\n",
    "df_control_21 = pd.read_csv('control_21.csv')\n",
    "df_control_22 = pd.read_csv('control_22.csv')\n",
    "df_control_23 = pd.read_csv('control_23.csv')\n",
    "df_control_24 = pd.read_csv('control_24.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.835390Z",
     "iopub.status.busy": "2023-10-10T10:21:38.834371Z",
     "iopub.status.idle": "2023-10-10T10:21:38.869096Z",
     "shell.execute_reply": "2023-10-10T10:21:38.867190Z"
    },
    "id": "o_lepn2LT5ny",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_control_04.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.931823Z",
     "iopub.status.busy": "2023-10-10T10:21:38.930928Z",
     "iopub.status.idle": "2023-10-10T10:21:38.965708Z",
     "shell.execute_reply": "2023-10-10T10:21:38.963776Z"
    }
   },
   "outputs": [],
   "source": [
    "df_pd_01.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:38.972840Z",
     "iopub.status.busy": "2023-10-10T10:21:38.972338Z",
     "iopub.status.idle": "2023-10-10T10:21:38.993835Z",
     "shell.execute_reply": "2023-10-10T10:21:38.991719Z"
    },
    "id": "cnajwOB9A2R1"
   },
   "outputs": [],
   "source": [
    "df_set1_1 = pd.concat([\n",
    "    df_control_01,df_control_06,df_control_11,df_control_20,df_control_15,\n",
    "    df_pd_25,df_pd_19,df_pd_01,df_pd_06\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_2 = pd.concat([\n",
    "    df_control_02,df_control_07,df_control_19,df_control_13,\n",
    "    df_pd_23,df_pd_18,df_pd_02,df_pd_07,df_pd_11\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_3 = pd.concat([\n",
    "    df_control_04,df_control_08,df_control_23,df_control_18,\n",
    "    df_pd_24,df_pd_15,df_pd_03,df_pd_08,df_pd_12\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_4 = pd.concat([\n",
    "    df_control_03,df_control_09,df_control_22,df_control_17,\n",
    "    df_pd_22,df_pd_16,df_pd_04,df_pd_09,df_pd_13\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_5 = pd.concat([\n",
    "    df_control_10,df_control_12,df_control_21,df_control_16,df_control_05,\n",
    "    df_pd_21,df_pd_17,df_pd_05,df_pd_10\n",
    "]).dropna(axis=0)\n",
    "\n",
    "#omit pd_14, pd_20 due to file shortage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.000725Z",
     "iopub.status.busy": "2023-10-10T10:21:39.000077Z",
     "iopub.status.idle": "2023-10-10T10:21:39.024977Z",
     "shell.execute_reply": "2023-10-10T10:21:39.023110Z"
    },
    "id": "4R1wZ9rwDD7e"
   },
   "outputs": [],
   "source": [
    "df_set1_test_1 = pd.concat([\n",
    "    df_control_01,df_control_06,df_control_11,df_control_20,df_control_15,\n",
    "    df_pd_25,df_pd_19,df_pd_01,df_pd_06,df_pd_14,df_pd_20,df_control_24\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_test_2 = pd.concat([\n",
    "    df_control_02,df_control_07,df_control_19,df_control_13,\n",
    "    df_pd_23,df_pd_18,df_pd_02,df_pd_07,df_pd_11,df_pd_14,df_pd_20,df_control_24\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_test_3 = pd.concat([\n",
    "    df_control_04,df_control_08,df_control_23,df_control_18,\n",
    "    df_pd_24,df_pd_15,df_pd_03,df_pd_08,df_pd_12,df_pd_14,df_pd_20,df_control_24\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_test_4 = pd.concat([\n",
    "    df_control_03,df_control_09,df_control_22,df_control_17,\n",
    "    df_pd_22,df_pd_16,df_pd_04,df_pd_09,df_pd_13,df_pd_14,df_pd_20,df_control_24\n",
    "]).dropna(axis=0)\n",
    "\n",
    "df_set1_test_5 = pd.concat([\n",
    "    df_control_10,df_control_12,df_control_21,df_control_16, df_control_05,\n",
    "    df_pd_21,df_pd_17,df_pd_05,df_pd_10,df_pd_14,df_pd_20,df_control_24\n",
    "]).dropna(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.032838Z",
     "iopub.status.busy": "2023-10-10T10:21:39.032338Z",
     "iopub.status.idle": "2023-10-10T10:21:39.044513Z",
     "shell.execute_reply": "2023-10-10T10:21:39.043147Z"
    }
   },
   "outputs": [],
   "source": [
    "df_1 = df_set1_1.drop(['stdevF0Hz'],axis=1)\n",
    "df_2 = df_set1_2.drop(['stdevF0Hz'],axis=1)\n",
    "df_3 = df_set1_3.drop(['stdevF0Hz'],axis=1)\n",
    "df_4 = df_set1_4.drop(['stdevF0Hz'],axis=1)\n",
    "df_5 = df_set1_5.drop(['stdevF0Hz'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.051108Z",
     "iopub.status.busy": "2023-10-10T10:21:39.050659Z",
     "iopub.status.idle": "2023-10-10T10:21:39.062586Z",
     "shell.execute_reply": "2023-10-10T10:21:39.060791Z"
    }
   },
   "outputs": [],
   "source": [
    "df_test_1 = df_set1_test_1.drop(['stdevF0Hz'],axis=1)\n",
    "df_test_2 = df_set1_test_2.drop(['stdevF0Hz'],axis=1)\n",
    "df_test_3 = df_set1_test_3.drop(['stdevF0Hz'],axis=1)\n",
    "df_test_4 = df_set1_test_4.drop(['stdevF0Hz'],axis=1)\n",
    "df_test_5 = df_set1_test_5.drop(['stdevF0Hz'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.068234Z",
     "iopub.status.busy": "2023-10-10T10:21:39.067755Z",
     "iopub.status.idle": "2023-10-10T10:21:39.076953Z",
     "shell.execute_reply": "2023-10-10T10:21:39.074899Z"
    }
   },
   "outputs": [],
   "source": [
    "print(df_1.shape)\n",
    "print(df_2.shape)\n",
    "print(df_3.shape)\n",
    "print(df_4.shape)\n",
    "print(df_5.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.081611Z",
     "iopub.status.busy": "2023-10-10T10:21:39.081163Z",
     "iopub.status.idle": "2023-10-10T10:21:39.089075Z",
     "shell.execute_reply": "2023-10-10T10:21:39.087726Z"
    }
   },
   "outputs": [],
   "source": [
    "print(df_test_1.shape)\n",
    "print(df_test_2.shape)\n",
    "print(df_test_3.shape)\n",
    "print(df_test_4.shape)\n",
    "print(df_test_5.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.094750Z",
     "iopub.status.busy": "2023-10-10T10:21:39.094209Z",
     "iopub.status.idle": "2023-10-10T10:21:39.102586Z",
     "shell.execute_reply": "2023-10-10T10:21:39.101333Z"
    }
   },
   "outputs": [],
   "source": [
    "os.listdir('DATASET_FULL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.106749Z",
     "iopub.status.busy": "2023-10-10T10:21:39.106250Z",
     "iopub.status.idle": "2023-10-10T10:21:39.117802Z",
     "shell.execute_reply": "2023-10-10T10:21:39.116120Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI = pd.read_fwf('DATASET_FULL/parkinsons.data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.122438Z",
     "iopub.status.busy": "2023-10-10T10:21:39.121993Z",
     "iopub.status.idle": "2023-10-10T10:21:39.130131Z",
     "shell.execute_reply": "2023-10-10T10:21:39.128719Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI['split'] = UCI['name,MDVP:Fo(Hz),MDVP:Fhi(Hz),MDVP:Flo(Hz),MDVP:Jitter(%),MDVP:Jitter(Abs),MDVP:RAP,MDVP:PPQ,Jitter:DDP,MDVP:Shimmer,MDVP:Shimmer(dB),Shimmer:APQ3,Shimmer:APQ5,MDVP:APQ,Shimmer:DDA,NHR,HNR,status,RPDE,DFA,spread1,spread2,D2,PPE'].str.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.134607Z",
     "iopub.status.busy": "2023-10-10T10:21:39.134161Z",
     "iopub.status.idle": "2023-10-10T10:21:39.142006Z",
     "shell.execute_reply": "2023-10-10T10:21:39.140922Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI = pd.DataFrame(UCI['split'].tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.145937Z",
     "iopub.status.busy": "2023-10-10T10:21:39.145542Z",
     "iopub.status.idle": "2023-10-10T10:21:39.172310Z",
     "shell.execute_reply": "2023-10-10T10:21:39.170304Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI.columns = ['voiceName','meanF0Hz','MDVP:Fhi(Hz)','MDVP:Flo(Hz)','localJitter','localabsoluteJitter','rapJitter','ppq5Jitter','ddpJitter','localShimmer','localdbShimmer','apq3Shimmer','apq5Shimmer','apq11Shimmer','ddaShimmer','NHR','HNR','class','RPDE','DFA','spread1','spread2','D2','PPE']\n",
    "UCI.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.178424Z",
     "iopub.status.busy": "2023-10-10T10:21:39.177979Z",
     "iopub.status.idle": "2023-10-10T10:21:39.184962Z",
     "shell.execute_reply": "2023-10-10T10:21:39.183579Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI_trim = UCI.drop(['spread1','spread2','D2','PPE','MDVP:Fhi(Hz)','MDVP:Flo(Hz)','NHR'], axis =1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.188911Z",
     "iopub.status.busy": "2023-10-10T10:21:39.188508Z",
     "iopub.status.idle": "2023-10-10T10:21:39.209220Z",
     "shell.execute_reply": "2023-10-10T10:21:39.207784Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI_trim.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.214824Z",
     "iopub.status.busy": "2023-10-10T10:21:39.214331Z",
     "iopub.status.idle": "2023-10-10T10:21:39.221682Z",
     "shell.execute_reply": "2023-10-10T10:21:39.220453Z"
    }
   },
   "outputs": [],
   "source": [
    "x_UCI = UCI_trim.drop(['voiceName','class'], axis = 1)\n",
    "y_UCI = UCI_trim['class']\n",
    "name = UCI_trim['voiceName']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.225444Z",
     "iopub.status.busy": "2023-10-10T10:21:39.225049Z",
     "iopub.status.idle": "2023-10-10T10:21:39.243235Z",
     "shell.execute_reply": "2023-10-10T10:21:39.241725Z"
    }
   },
   "outputs": [],
   "source": [
    "x_UCI = x_UCI.apply(pd.to_numeric, errors = 'coerce')\n",
    "y_UCI = y_UCI.apply(pd.to_numeric, errors = 'coerce')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.248103Z",
     "iopub.status.busy": "2023-10-10T10:21:39.247661Z",
     "iopub.status.idle": "2023-10-10T10:21:39.254722Z",
     "shell.execute_reply": "2023-10-10T10:21:39.253448Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI_new = pd.concat([name,x_UCI,y_UCI],axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.262964Z",
     "iopub.status.busy": "2023-10-10T10:21:39.262515Z",
     "iopub.status.idle": "2023-10-10T10:21:39.288178Z",
     "shell.execute_reply": "2023-10-10T10:21:39.286162Z"
    }
   },
   "outputs": [],
   "source": [
    "UCI_new.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.297527Z",
     "iopub.status.busy": "2023-10-10T10:21:39.297031Z",
     "iopub.status.idle": "2023-10-10T10:21:39.325961Z",
     "shell.execute_reply": "2023-10-10T10:21:39.324673Z"
    }
   },
   "outputs": [],
   "source": [
    "subjects = ['S01','S34','S44','S20','S24','S26','S08','S39',\n",
    "            'S33','S32','S02','S22','S37','S21','S04','S19',\n",
    "            'S35','S05','S18','S16','S27','S25','S06','S10',\n",
    "            'S07','S13','S43','S17','S42','S50','S49']\n",
    "\n",
    "all_dataframes = list()\n",
    "for s in subjects:\n",
    "  s = UCI_new.voiceName.str.contains(s)\n",
    "  df_UCI = UCI_new[s]\n",
    "  all_dataframes.append(df_UCI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.332180Z",
     "iopub.status.busy": "2023-10-10T10:21:39.331721Z",
     "iopub.status.idle": "2023-10-10T10:21:39.345638Z",
     "shell.execute_reply": "2023-10-10T10:21:39.343921Z"
    }
   },
   "outputs": [],
   "source": [
    "#omint dataframe 2, 7, 8 bc of imbalance & close to mean\n",
    "cv1 = pd.concat([all_dataframes[0],all_dataframes[21],all_dataframes[23],\n",
    "                 all_dataframes[5],all_dataframes[20],all_dataframes[22],all_dataframes[28]])\n",
    "cv2 = pd.concat([all_dataframes[1],all_dataframes[11],all_dataframes[25],\n",
    "                 all_dataframes[6],all_dataframes[14],all_dataframes[16],all_dataframes[26]])\n",
    "cv3 = pd.concat([all_dataframes[3],all_dataframes[19],all_dataframes[27],\n",
    "                 all_dataframes[9],all_dataframes[13],all_dataframes[30],all_dataframes[18]])\n",
    "cv4 = pd.concat([all_dataframes[4],all_dataframes[12],all_dataframes[24],\n",
    "                 all_dataframes[10],all_dataframes[15],all_dataframes[29],all_dataframes[17]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.352495Z",
     "iopub.status.busy": "2023-10-10T10:21:39.351863Z",
     "iopub.status.idle": "2023-10-10T10:21:39.360733Z",
     "shell.execute_reply": "2023-10-10T10:21:39.358623Z"
    },
    "id": "h401vAQWnStn"
   },
   "outputs": [],
   "source": [
    "def drop(df):\n",
    "  x_label = df['voiceName']\n",
    "  x_drop = df.drop(['voiceName','class'],axis=1)\n",
    "  y_drop = df['class']\n",
    "  return x_drop, y_drop, x_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.366808Z",
     "iopub.status.busy": "2023-10-10T10:21:39.366245Z",
     "iopub.status.idle": "2023-10-10T10:21:39.377314Z",
     "shell.execute_reply": "2023-10-10T10:21:39.375914Z"
    }
   },
   "outputs": [],
   "source": [
    "cv1 = drop(cv1)\n",
    "cv2 = drop(cv2)\n",
    "cv3 = drop(cv3)\n",
    "cv4 = drop(cv4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.382355Z",
     "iopub.status.busy": "2023-10-10T10:21:39.381949Z",
     "iopub.status.idle": "2023-10-10T10:21:39.388814Z",
     "shell.execute_reply": "2023-10-10T10:21:39.387414Z"
    }
   },
   "outputs": [],
   "source": [
    "x_cv1, y_cv1 = cv1[0], cv1[1]\n",
    "x_cv2, y_cv2 = cv2[0], cv2[1]\n",
    "x_cv3, y_cv3 = cv3[0], cv3[1]\n",
    "x_cv4, y_cv4 = cv4[0], cv4[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.393890Z",
     "iopub.status.busy": "2023-10-10T10:21:39.393457Z",
     "iopub.status.idle": "2023-10-10T10:21:39.410439Z",
     "shell.execute_reply": "2023-10-10T10:21:39.408307Z"
    },
    "id": "YEeo4SF0Ax74"
   },
   "outputs": [],
   "source": [
    "df_1 = drop(df_1)\n",
    "df_2 = drop(df_2)\n",
    "df_3 = drop(df_3)\n",
    "df_4 = drop(df_4)\n",
    "df_5 = drop(df_5)\n",
    "\n",
    "df_test_1 = drop(df_test_1)\n",
    "df_test_2 = drop(df_test_2)\n",
    "df_test_3 = drop(df_test_3)\n",
    "df_test_4 = drop(df_test_4)\n",
    "df_test_5 = drop(df_test_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.416615Z",
     "iopub.status.busy": "2023-10-10T10:21:39.416167Z",
     "iopub.status.idle": "2023-10-10T10:21:39.570946Z",
     "shell.execute_reply": "2023-10-10T10:21:39.568930Z"
    },
    "id": "AsEPG6TtAeHA"
   },
   "outputs": [],
   "source": [
    "x_df1, y_df1 = df_1[0], df_1[1]\n",
    "x_df2, y_df2 = df_2[0], df_2[1]\n",
    "x_df3, y_df3 = df_3[0], df_3[1]\n",
    "x_df4, y_df4 = df_4[0], df_4[1]\n",
    "x_df5, y_df5 = df_5[0], df_5[1]\n",
    "\n",
    "x_df_test_1, y_df_test_1, test_label_1 = df_test_1[0], df_test_1[1], df_test_1[2]\n",
    "x_df_test_2, y_df_test_2, test_label_2 = df_test_2[0], df_test_2[1], df_test_2[2]\n",
    "x_df_test_3, y_df_test_3, test_label_3 = df_test_3[0], df_test_3[1], df_test_3[2]\n",
    "x_df_test_4, y_df_test_4, test_label_4 = df_test_4[0], df_test_4[1], df_test_4[2]\n",
    "x_df_test_5, y_df_test_5, test_label_5 = df_test_5[0], df_test_5[1], df_test_5[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.578866Z",
     "iopub.status.busy": "2023-10-10T10:21:39.578358Z",
     "iopub.status.idle": "2023-10-10T10:21:39.590255Z",
     "shell.execute_reply": "2023-10-10T10:21:39.588830Z"
    },
    "id": "kRl2x8AoqfRS"
   },
   "outputs": [],
   "source": [
    "#remove unneccessary strings from name\n",
    "test_label_1 = np.array(test_label_1.str.replace(r'/content/drive/MyDrive/pd thesis/PD_DATA_1/PD_data_final_set1', '', regex=True).tolist())\n",
    "test_label_2 = np.array(test_label_2.str.replace(r'/content/drive/MyDrive/pd thesis/PD_DATA_1/PD_data_final_set1', '', regex=True).tolist())\n",
    "test_label_3 = np.array(test_label_3.str.replace(r'/content/drive/MyDrive/pd thesis/PD_DATA_1/PD_data_final_set1', '', regex=True).tolist())\n",
    "test_label_4 = np.array(test_label_4.str.replace(r'/content/drive/MyDrive/pd thesis/PD_DATA_1/PD_data_final_set1', '', regex=True).tolist())\n",
    "test_label_5 = np.array(test_label_5.str.replace(r'/content/drive/MyDrive/pd thesis/PD_DATA_1/PD_data_final_set1', '', regex=True).tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ofRiNRo0oqAG"
   },
   "source": [
    "#Make Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.595900Z",
     "iopub.status.busy": "2023-10-10T10:21:39.595470Z",
     "iopub.status.idle": "2023-10-10T10:21:39.610593Z",
     "shell.execute_reply": "2023-10-10T10:21:39.609195Z"
    },
    "id": "5ayr9axm4f_r"
   },
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.feature_selection import RFE\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC, LinearSVC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.615870Z",
     "iopub.status.busy": "2023-10-10T10:21:39.615356Z",
     "iopub.status.idle": "2023-10-10T10:21:39.624095Z",
     "shell.execute_reply": "2023-10-10T10:21:39.622679Z"
    },
    "id": "q1N2Xv2lf1_k"
   },
   "outputs": [],
   "source": [
    "svm_rbf = SVC(kernel='rbf', probability= True)\n",
    "svm_linear = SVC(kernel='linear',probability = True)\n",
    "\n",
    "C_range1 = [1]\n",
    "C_range2 = np.logspace(0,2,20,endpoint=True)\n",
    "\n",
    "gamma_range1 = [0.009, 0.015]\n",
    "gamma_range2 = np.linspace(0.01,1,100,endpoint=True)\n",
    "\n",
    "param_grid1 = dict(SVC__C=C_range1, SVC__gamma = gamma_range1)\n",
    "param_grid2 = dict(SVC__C=C_range2, SVC__gamma = gamma_range2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.629701Z",
     "iopub.status.busy": "2023-10-10T10:21:39.629236Z",
     "iopub.status.idle": "2023-10-10T10:21:39.635398Z",
     "shell.execute_reply": "2023-10-10T10:21:39.634028Z"
    },
    "id": "jhtZmgXbx4Y7"
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "from numpy import sqrt, argmax\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.640165Z",
     "iopub.status.busy": "2023-10-10T10:21:39.639669Z",
     "iopub.status.idle": "2023-10-10T10:21:39.647426Z",
     "shell.execute_reply": "2023-10-10T10:21:39.645085Z"
    },
    "id": "FBTfk37Bf7Bk"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import PredefinedSplit, GridSearchCV\n",
    "from sklearn.metrics import classification_report, confusion_matrix, precision_recall_fscore_support, roc_curve, precision_recall_curve, auc, f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.654327Z",
     "iopub.status.busy": "2023-10-10T10:21:39.653291Z",
     "iopub.status.idle": "2023-10-10T10:21:39.671409Z",
     "shell.execute_reply": "2023-10-10T10:21:39.669391Z"
    },
    "id": "W7BILxjRCxy2"
   },
   "outputs": [],
   "source": [
    "def roc(yhat,y_test):\n",
    "  fpr, tpr, thresholds = roc_curve(y_test, yhat)\n",
    "  roc_auc = auc(fpr, tpr)\n",
    "  # calculate the g-mean for each threshold\n",
    "  gmeans = sqrt(tpr * (1-fpr))\n",
    "  # locate the index of the largest g-mean\n",
    "  ix = argmax(gmeans)\n",
    "  plt.figure(figsize=(4,3))\n",
    "  # plot the roc curve for the model\n",
    "  plt.plot([0,1], [0,1], linestyle='--', label='No Skill')\n",
    "  plt.plot(fpr, tpr, marker='.', label='AUC = %0.2f' % roc_auc)\n",
    "  plt.scatter(fpr[ix], tpr[ix], marker='o', color='black', label='Best')\n",
    "  # axis labels\n",
    "  plt.xlabel('False Positive Rate')\n",
    "  plt.ylabel('True Positive Rate')\n",
    "  plt.legend()\n",
    "  # show the plot\n",
    "  plt.show()\n",
    "  #show scores\n",
    "  print('Best Threshold=%f, G-Mean=%.3f' % (thresholds[ix], gmeans[ix]))\n",
    "  return thresholds[ix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.676479Z",
     "iopub.status.busy": "2023-10-10T10:21:39.676018Z",
     "iopub.status.idle": "2023-10-10T10:21:39.687538Z",
     "shell.execute_reply": "2023-10-10T10:21:39.685279Z"
    },
    "id": "5MPaFl7h-_OL"
   },
   "outputs": [],
   "source": [
    "def prt(yhat,y_test):\n",
    "  precision, recall, thresholds = precision_recall_curve(y_test, yhat)\n",
    "  fscore = (2 * precision * recall) / (precision + recall)\n",
    "  # locate the index of the largest f score\n",
    "  ix = argmax(fscore)\n",
    "  plt.figure(figsize=(4,3))\n",
    "\n",
    "  # plot the roc curve for the model\n",
    "  no_skill = len(y_test[y_test==1]) / len(y_test)\n",
    "  plt.plot([0,1], [no_skill,no_skill], linestyle='--', label='No Skill')\n",
    "  plt.plot(recall, precision, marker='.', label='SVC')\n",
    "  plt.scatter(recall[ix], precision[ix], marker='o', color='black', label='Best')\n",
    "  # axis labels\n",
    "  plt.xlabel('Recall')\n",
    "  plt.ylabel('Precision')\n",
    "  plt.legend()\n",
    "  # show the plot\n",
    "  plt.show()\n",
    "  print('Best Threshold=%f, F-Score=%.3f' % (thresholds[ix], fscore[ix]))\n",
    "  return thresholds[ix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.693639Z",
     "iopub.status.busy": "2023-10-10T10:21:39.692970Z",
     "iopub.status.idle": "2023-10-10T10:21:39.702167Z",
     "shell.execute_reply": "2023-10-10T10:21:39.700665Z"
    },
    "id": "KG0nlB9hFTPh"
   },
   "outputs": [],
   "source": [
    "def plot(x,y,label1):\n",
    "  plt.plot(x,y, label = label1)\n",
    "  plt.xlabel('Number of features used')\n",
    "  plt.ylabel('Score')\n",
    "  plt.legend(loc='best')\n",
    "  plt.grid(axis = 'x')\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.708356Z",
     "iopub.status.busy": "2023-10-10T10:21:39.707832Z",
     "iopub.status.idle": "2023-10-10T10:21:39.723197Z",
     "shell.execute_reply": "2023-10-10T10:21:39.721034Z"
    },
    "id": "VGzcfcbeoCbC"
   },
   "outputs": [],
   "source": [
    "def classifierSVM_PD(x_one,y_one,x_two,y_two,x_three,y_three,x_four,y_four,param):\n",
    "\n",
    "  pipe = Pipeline(steps=[\n",
    "    (\"scaler\", StandardScaler()),\n",
    "    (\"SVC\", SVC(kernel = 'rbf', probability = True)),\n",
    "  ])\n",
    "\n",
    "  nil_idx = np.repeat(0,y_one.shape)\n",
    "  one_idx = np.repeat(1,y_two.shape)\n",
    "  two_idx = np.repeat(2,y_three.shape)\n",
    "  three_idx = np.repeat(3,y_four.shape)\n",
    "\n",
    "  list_idx = [nil_idx, one_idx, two_idx, three_idx]\n",
    "  split = np.array([])\n",
    "\n",
    "  for i in list_idx:\n",
    "    split = np.append(split,i)\n",
    "\n",
    "  validation_split = list(PredefinedSplit(split).split())\n",
    "\n",
    "  x_input = np.concatenate((x_one, x_two, x_three, x_four))\n",
    "  y_input = np.concatenate((y_one, y_two, y_three, y_four))\n",
    "\n",
    "  grid_search = GridSearchCV(\n",
    "      estimator = pipe,\n",
    "      param_grid = param,\n",
    "      verbose = 1,\n",
    "      cv = validation_split,\n",
    "      n_jobs = -1,\n",
    "      scoring = 'f1_macro'\n",
    "  )\n",
    "\n",
    "  grid_search = grid_search.fit(x_input,y_input)\n",
    "\n",
    "  return grid_search.best_score_, grid_search.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.728218Z",
     "iopub.status.busy": "2023-10-10T10:21:39.727766Z",
     "iopub.status.idle": "2023-10-10T10:21:39.738296Z",
     "shell.execute_reply": "2023-10-10T10:21:39.736948Z"
    },
    "id": "82c7SjxTrQ6e"
   },
   "outputs": [],
   "source": [
    "def clf_test(c, g, x_train, y_train, x_test, y_test,threshold):\n",
    "\n",
    "  clf_for_test = SVC(C = c, gamma = g, kernel = 'rbf', probability = True)\n",
    "  test_pipe = Pipeline(steps=[\n",
    "    (\"scaler\", StandardScaler()),\n",
    "    (\"SVC\", clf_for_test),\n",
    "  ])\n",
    "\n",
    "  test_pipe.fit(x_train, y_train)\n",
    "  y_hat = test_pipe.predict_proba(x_test)[:,1]\n",
    "  #must set threshold to some value y_hat.astype(bool) will change every result to positive\n",
    "  y_pred = (y_hat >= threshold).astype(bool)\n",
    "    \n",
    "  scores = precision_recall_fscore_support(y_test, y_pred, average='binary')\n",
    "  f1_macro = f1_score(y_test, y_pred, average = 'macro')\n",
    "\n",
    "  print('Test set ROC curve result')\n",
    "  roc(y_hat, y_test)\n",
    "  print('-------------------------------------------')\n",
    "  print('Test set Precision-recall curve result')\n",
    "  prt(y_hat, y_test)\n",
    "  print('-------------------------------------------')\n",
    "\n",
    "  print('Test report')\n",
    "  print(classification_report(y_test, y_pred))\n",
    "  print(confusion_matrix(y_test, y_pred))\n",
    "\n",
    "  return y_pred, scores, f1_macro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.743527Z",
     "iopub.status.busy": "2023-10-10T10:21:39.743067Z",
     "iopub.status.idle": "2023-10-10T10:21:39.750894Z",
     "shell.execute_reply": "2023-10-10T10:21:39.749487Z"
    }
   },
   "outputs": [],
   "source": [
    "def right_wrong_clf(y_test,y_pred_test, x_name_list):\n",
    "  y_test_nparr = np.array(y_test)\n",
    "  y_pred_test = np.array(y_pred_test)\n",
    "\n",
    "  classification_is_right = y_test == y_pred_test\n",
    "  classification_is_wrong = y_test != y_pred_test\n",
    "\n",
    "  right_clf = x_name_list[classification_is_right]\n",
    "  wrong_clf = x_name_list[classification_is_wrong]\n",
    "  print(f'There are {len(wrong_clf)} misclassification from {len(wrong_clf)+len(right_clf)} voice files.')\n",
    "  return right_clf, wrong_clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.756613Z",
     "iopub.status.busy": "2023-10-10T10:21:39.756173Z",
     "iopub.status.idle": "2023-10-10T10:21:39.788685Z",
     "shell.execute_reply": "2023-10-10T10:21:39.787308Z"
    },
    "id": "VjpDVJQcpmqW"
   },
   "outputs": [],
   "source": [
    "def l1_feature_selection(x_name_list,x_one,y_one,x_two,y_two,x_three,y_three,x_four,y_four,x_test,y_test,num_features,param,name):\n",
    "\n",
    "  features_list = []\n",
    "  sel_feat_list = []\n",
    "\n",
    "  x_one_list =[]\n",
    "  x_two_list = []\n",
    "  x_three_list = []\n",
    "  x_four_list = []\n",
    "  x_test_list = []\n",
    "\n",
    "  best_score_list = []\n",
    "  best_params_list = []\n",
    "\n",
    "  x_one = pd.concat([x_one,x_cv1])\n",
    "  x_two = pd.concat([x_two,x_cv2])\n",
    "  x_three = pd.concat([x_three,x_cv3])\n",
    "  x_four = pd.concat([x_four,x_cv4])\n",
    "\n",
    "  y_one = pd.concat([y_one,y_cv1])\n",
    "  y_two = pd.concat([y_two,y_cv2])\n",
    "  y_three = pd.concat([y_three,y_cv3])\n",
    "  y_four = pd.concat([y_four,y_cv4])\n",
    "\n",
    "  #We won't scale anything in feature selection process -> summing train/val datasets together\n",
    "  x_for_cl = pd.concat([x_one, x_two, x_three, x_four])\n",
    "  y_for_cl = pd.concat([y_one, y_two, y_three, y_four])\n",
    "\n",
    "  #L1-norm feature selection algorithm\n",
    "  for n in range(1,num_features+1):\n",
    "    df = pd.DataFrame(x_for_cl, columns = ['meanF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA'])\n",
    "\n",
    "    sel = SelectFromModel(LinearSVC(penalty = 'l1', max_iter = 10000, dual = False), threshold=-np.inf, max_features = n)\n",
    "    sel.fit(x_for_cl, y_for_cl)\n",
    "\n",
    "    #caching feature lists in each iteration\n",
    "    sel_feat = df.columns[(sel.get_support())]\n",
    "    sel_feat_list.append(sel_feat)\n",
    "\n",
    "    #transform data and caching each iteration\n",
    "    x_one_selected = sel.transform(x_one)\n",
    "    x_one_list.append(x_one_selected)\n",
    "\n",
    "    x_two_selected = sel.transform(x_two)\n",
    "    x_two_list.append(x_two_selected)\n",
    "\n",
    "    x_three_selected = sel.transform(x_three)\n",
    "    x_three_list.append(x_three_selected)\n",
    "\n",
    "    x_four_selected = sel.transform(x_four)\n",
    "    x_four_list.append(x_four_selected)\n",
    "\n",
    "    x_test_selected = sel.transform(x_test)\n",
    "    x_test_list.append(x_test_selected)\n",
    "\n",
    "    print(f'Results when using {n} features')\n",
    "    print(f'Selected features are {sel_feat}.')\n",
    "\n",
    "    cc = classifierSVM_PD(x_one_selected, y_one, x_two_selected, y_two, x_three_selected, y_three, x_four_selected, y_four, param)\n",
    "    print(' ')\n",
    "    print(f'The parameters are {cc[1]} with f1-macro score at {cc[0]}')\n",
    "    print('-------------------------------------------------------------------------- ')\n",
    "\n",
    "    #caching best_score, best_param of each iteration\n",
    "    best_score_list.append(cc[0])\n",
    "    best_params_list.append(cc[1])\n",
    "\n",
    "    #caching independent features for counting occurrences at the end of the program\n",
    "    for i in range(0,len(sel_feat)):\n",
    "      features_list.append(sel_feat[i])\n",
    "    \n",
    "\n",
    "  #counting feature occurrences\n",
    "  feature_dict = collections.Counter(features_list)\n",
    "  df_feature_count = pd.DataFrame.from_dict(feature_dict, orient='index').transpose()\n",
    "  df_rename = df_feature_count.rename(index={0:name})\n",
    "\n",
    "  print(' ')\n",
    "\n",
    "  best_index = np.argmax(best_score_list)\n",
    "  print(f'The best model use {best_index+1} features.')\n",
    "\n",
    "  b_params = best_params_list[best_index]\n",
    "  b_score = best_score_list[best_index]\n",
    "  print(f'The parameter of this model are {b_params} with f1-macro score at {b_score}.')\n",
    "\n",
    "  best_sel_feat = sel_feat_list[best_index]\n",
    "  print(f'The features of this model consist of {best_sel_feat}')\n",
    "    \n",
    "  print('---------------------------------------------------------')\n",
    "\n",
    "  plot(np.linspace(1,num_features,num_features,endpoint =True,dtype=int),best_score_list,'F1-macro score')\n",
    "\n",
    "  #selecting datasets that create the best classifier\n",
    "  x_one_best = x_one_list[best_index]\n",
    "  x_two_best = x_two_list[best_index]\n",
    "  x_three_best = x_three_list[best_index]\n",
    "  x_four_best = x_four_list[best_index]\n",
    "  x_test_best = x_test_list[best_index]\n",
    "\n",
    "  if (x_one_best.shape[1] or x_two_best.shape[1] or x_three_best.shape[1] or x_four_best.shape[1]) != (best_index +1):\n",
    "    print('Error')\n",
    "\n",
    "  print('---------------------------------------------------------')\n",
    "\n",
    " #summing train/val data to feed into a test classifier\n",
    "  x_all = np.concatenate((x_one_best, x_two_best, x_three_best, x_four_best))\n",
    "  y_all = np.concatenate((y_one, y_two, y_three, y_four))\n",
    "\n",
    "  pred_test = clf_test(b_params['SVC__C'], b_params['SVC__gamma'], x_all, y_all, x_test_best, y_test,0.5)\n",
    "  y_pred_test = pred_test[0]\n",
    "    \n",
    "  #checking the number/id of incorrect classification\n",
    "  rw_fixthreshold = right_wrong_clf(y_test,y_pred_test,x_name_list)\n",
    "    \n",
    "  print('---------------------------------------------------------')\n",
    "\n",
    "  ##thresh = clf_varied_threshold(b_params['SVC__C'], b_params['SVC__gamma'],\n",
    "                       #x_one_best,y_one,x_two_best,y_two,x_three_best,y_three,x_four_best,y_four)\n",
    "    \n",
    "  ##pred_test_thresh = clf_test(b_params['SVC__C'], b_params['SVC__gamma'], x_all, y_all, x_test_best, y_test,thresh) \n",
    "\n",
    "  summary_columns =  ['1 feature','2 features','3 features','4 features','5 features',\n",
    "                                    '6 features','7 features','8 features','9 features','10 features',\n",
    "                                    '11 features','12 features','13 features','14 features','15 features'\n",
    "  ]\n",
    "\n",
    "  df_best_score = pd.DataFrame(\n",
    "      data = best_score_list,\n",
    "      columns = [name]\n",
    "  ).T\n",
    "\n",
    "  df_best_score.columns = summary_columns\n",
    "  \n",
    "  df_best_params = pd.DataFrame.from_dict(\n",
    "      data =best_params_list\n",
    "  )\n",
    "  \n",
    "  df_best_c = pd.DataFrame(df_best_params['SVC__C'])\n",
    "  df_best_gamma = pd.DataFrame(df_best_params['SVC__gamma'])\n",
    "\n",
    "  df_best_c.columns = [name]\n",
    "  df_best_gamma.columns = [name]\n",
    "\n",
    "  df_best_c = df_best_c.T\n",
    "  df_best_gamma = df_best_gamma.T\n",
    "    \n",
    "  df_best_c.columns = summary_columns\n",
    "  df_best_gamma.columns = summary_columns\n",
    "  \n",
    "  return (df_rename, rw_fixthreshold[0], rw_fixthreshold[1], df_best_score, df_best_c, \n",
    "          df_best_gamma, best_score_list, pred_test[1][1], pred_test[2], best_sel_feat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.796752Z",
     "iopub.status.busy": "2023-10-10T10:21:39.796232Z",
     "iopub.status.idle": "2023-10-10T10:21:39.829519Z",
     "shell.execute_reply": "2023-10-10T10:21:39.828026Z"
    },
    "id": "88Uwt8AfA1OL"
   },
   "outputs": [],
   "source": [
    "def rfe(x_name_list,x_one,y_one,x_two,y_two,x_three,y_three,x_four,y_four,x_test,y_test,num_features,param,name):\n",
    "\n",
    "  features_list = []\n",
    "  sel_feat_list = []\n",
    "\n",
    "  x_one_list =[]\n",
    "  x_two_list = []\n",
    "  x_three_list = []\n",
    "  x_four_list = []\n",
    "  x_test_list = []\n",
    "\n",
    "  best_score_list = []\n",
    "  best_params_list = []\n",
    "\n",
    "  x_one = pd.concat([x_one,x_cv1])\n",
    "  x_two = pd.concat([x_two,x_cv2])\n",
    "  x_three = pd.concat([x_three,x_cv3])\n",
    "  x_four = pd.concat([x_four,x_cv4])\n",
    "\n",
    "  y_one = pd.concat([y_one,y_cv1])\n",
    "  y_two = pd.concat([y_two,y_cv2])\n",
    "  y_three = pd.concat([y_three,y_cv3])\n",
    "  y_four = pd.concat([y_four,y_cv4])\n",
    "\n",
    "  #We won't scale anything in feature selection process -> summing train/val datasets together\n",
    "  x_for_cl = pd.concat([x_one, x_two, x_three, x_four])\n",
    "  y_for_cl = pd.concat([y_one, y_two, y_three, y_four])\n",
    "\n",
    "  #RFE feature selection algorithm\n",
    "\n",
    "  for n in range(1,num_features+1):\n",
    "    df = pd.DataFrame(x_for_cl, columns = ['meanF0Hz', 'HNR', 'localJitter', 'localabsoluteJitter', 'rapJitter',\n",
    "                                        'ppq5Jitter', 'ddpJitter', 'localShimmer', 'localdbShimmer', 'apq3Shimmer', 'apq5Shimmer',\n",
    "                                        'apq11Shimmer', 'ddaShimmer', 'RPDE', 'DFA'])\n",
    "\n",
    "    rfe = RFE(estimator= LinearSVC(penalty = 'l2', max_iter = 10000, dual = False), n_features_to_select = n, step = 1)\n",
    "    rfe.fit(x_for_cl,y_for_cl)\n",
    "\n",
    "    #caching feature lists in each iteration\n",
    "    rfe_feat = df.columns[(rfe.support_)]\n",
    "    sel_feat_list.append(rfe_feat)\n",
    "\n",
    "    #transform data and caching each iteration\n",
    "    x_one_selected = rfe.transform(x_one)\n",
    "    x_one_list.append(x_one_selected)\n",
    "\n",
    "    x_two_selected = rfe.transform(x_two)\n",
    "    x_two_list.append(x_two_selected)\n",
    "\n",
    "    x_three_selected = rfe.transform(x_three)\n",
    "    x_three_list.append(x_three_selected)\n",
    "\n",
    "    x_four_selected = rfe.transform(x_four)\n",
    "    x_four_list.append(x_four_selected)\n",
    "\n",
    "    x_test_selected = rfe.transform(x_test)\n",
    "    x_test_list.append(x_test_selected)\n",
    "\n",
    "    print(f'Results when using {n} features')\n",
    "    print(f'Selected features are {rfe_feat}.')\n",
    "\n",
    "    cc = classifierSVM_PD(x_one_selected, y_one, x_two_selected, y_two, x_three_selected, y_three, x_four_selected, y_four, param)\n",
    "    print(' ')\n",
    "    print(f'The parameters are {cc[1]} with f1-macro score at {cc[0]}')\n",
    "    print('-------------------------------------------------------------------------- ')\n",
    "\n",
    "    #caching best_score, best_param of each iteration\n",
    "    best_score_list.append(cc[0])\n",
    "    best_params_list.append(cc[1])\n",
    "\n",
    "    #caching independent features for counting occurrences at the end of the program\n",
    "    for i in range(0,len(rfe_feat)):\n",
    "      features_list.append(rfe_feat[i])\n",
    "\n",
    "\n",
    "  #counting feature occurrences\n",
    "  feature_dict = collections.Counter(features_list)\n",
    "  df_feature_count = pd.DataFrame.from_dict(feature_dict, orient='index').transpose()\n",
    "  df_rename = df_feature_count.rename(index={0:name})\n",
    "\n",
    "  print(' ')\n",
    "\n",
    "  best_index = np.argmax(best_score_list)\n",
    "  print(f'The best model use {best_index+1} features.')\n",
    "\n",
    "  b_params = best_params_list[best_index]\n",
    "  b_score = best_score_list[best_index]\n",
    "  print(f'The parameter of this model are {b_params} with f1-macro score at {b_score}.')\n",
    "\n",
    "  best_sel_feat = sel_feat_list[best_index]\n",
    "  print(f'The features of this model consist of {best_sel_feat}')\n",
    "\n",
    "  print('---------------------------------------------------------')\n",
    "\n",
    "  plot(np.linspace(1,num_features,num_features,endpoint =True,dtype=int),best_score_list,'F1-macro score')\n",
    "\n",
    "    #selecting datasets that create the best classifier\n",
    "  x_one_best = x_one_list[best_index]\n",
    "  x_two_best = x_two_list[best_index]\n",
    "  x_three_best = x_three_list[best_index]\n",
    "  x_four_best = x_four_list[best_index]\n",
    "  x_test_best = x_test_list[best_index]\n",
    "\n",
    "  if (x_one_best.shape[1] or x_two_best.shape[1] or x_three_best.shape[1] or x_four_best.shape[1]) != (best_index +1):\n",
    "    print('Error')\n",
    "\n",
    "  print('---------------------------------------------------------')\n",
    "\n",
    " #summing train/val data to feed into a test classifier\n",
    "  x_all = np.concatenate((x_one_best, x_two_best, x_three_best, x_four_best))\n",
    "  y_all = np.concatenate((y_one, y_two, y_three, y_four))\n",
    "\n",
    "  pred_test = clf_test(b_params['SVC__C'], b_params['SVC__gamma'], x_all, y_all, x_test_best, y_test,0.5)\n",
    "  y_pred_test = pred_test[0]\n",
    "\n",
    "  #checking the number/id of incorrect classification\n",
    "  rw_fixthreshold = right_wrong_clf(y_test,y_pred_test,x_name_list)\n",
    "    \n",
    "  print('---------------------------------------------------------')\n",
    "    \n",
    "  ##thresh = clf_varied_threshold(b_params['SVC__C'], b_params['SVC__gamma'],\n",
    "                       #x_one_best,y_one,x_two_best,y_two,x_three_best,y_three,x_four_best,y_four)\n",
    "    \n",
    "  ##pred_test_thresh = clf_test(b_params['SVC__C'], b_params['SVC__gamma'], x_all, y_all, x_test_best, y_test,thresh) \n",
    "\n",
    "  summary_columns =  ['1 feature','2 features','3 features','4 features','5 features',\n",
    "                                      '6 features','7 features','8 features','9 features','10 features',\n",
    "                                      '11 features','12 features','13 features','14 features','15 features'\n",
    "  ]\n",
    "\n",
    "  df_best_score = pd.DataFrame(\n",
    "      data = best_score_list,\n",
    "      columns = [name]\n",
    "  ).T\n",
    "\n",
    "  df_best_score.columns = summary_columns\n",
    "\n",
    "  df_best_params = pd.DataFrame.from_dict(\n",
    "      data =best_params_list\n",
    "  )\n",
    "  \n",
    "  df_best_c = pd.DataFrame(df_best_params['SVC__C'])\n",
    "  df_best_gamma = pd.DataFrame(df_best_params['SVC__gamma'])\n",
    "\n",
    "  df_best_c.columns = [name]\n",
    "  df_best_gamma.columns = [name]\n",
    "\n",
    "  df_best_c = df_best_c.T\n",
    "  df_best_gamma = df_best_gamma.T\n",
    "    \n",
    "  df_best_c.columns = summary_columns\n",
    "  df_best_gamma.columns = summary_columns\n",
    "  \n",
    "  return (df_rename, rw_fixthreshold[0], rw_fixthreshold[1], df_best_score, df_best_c, \n",
    "          df_best_gamma, best_score_list, pred_test[1][1], pred_test[2], best_sel_feat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.837909Z",
     "iopub.status.busy": "2023-10-10T10:21:39.837392Z",
     "iopub.status.idle": "2023-10-10T10:21:39.848837Z",
     "shell.execute_reply": "2023-10-10T10:21:39.846684Z"
    }
   },
   "outputs": [],
   "source": [
    "subject_list = ['Dataset1_half_toserver/PD_01','Dataset1_half_toserver/PD_02','Dataset1_half_toserver/PD_03',\n",
    "                'Dataset1_half_toserver/PD_04','Dataset1_half_toserver/PD_05','Dataset1_half_toserver/PD_06',\n",
    "                'Dataset1_half_toserver/PD_07','Dataset1_half_toserver/PD_08','Dataset1_half_toserver/PD_09',\n",
    "                'Dataset1_half_toserver/PD_10','Dataset1_half_toserver/PD_11','Dataset1_half_toserver/PD_12',\n",
    "                'Dataset1_half_toserver/PD_13','Dataset1_half_toserver/PD_14','Dataset1_half_toserver/PD_15',\n",
    "                'Dataset1_half_toserver/PD_16','Dataset1_half_toserver/PD_17','Dataset1_half_toserver/PD_18',\n",
    "                'Dataset1_half_toserver/PD_19','Dataset1_half_toserver/PD_20','Dataset1_half_toserver/PD_21',\n",
    "                'Dataset1_half_toserver/PD_22','Dataset1_half_toserver/PD_23','Dataset1_half_toserver/PD_24','Dataset1_half_toserver/PD_25',\n",
    "                'Dataset1_half_toserver/Control_01','Dataset1_half_toserver/Control_02','Dataset1_half_toserver/Control_03',\n",
    "                'Dataset1_half_toserver/Control_04','Dataset1_half_toserver/Control_05','Dataset1_half_toserver/Control_06',\n",
    "                'Dataset1_half_toserver/Control_07','Dataset1_half_toserver/Control_08','Dataset1_half_toserver/Control_09',\n",
    "                'Dataset1_half_toserver/Control_10','Dataset1_half_toserver/Control_11','Dataset1_half_toserver/Control_12',\n",
    "                'Dataset1_half_toserver/Control_13','Dataset1_half_toserver/Control_15','Dataset1_half_toserver/Control_16',\n",
    "                'Dataset1_half_toserver/Control_17','Dataset1_half_toserver/Control_18','Dataset1_half_toserver/Control_19',\n",
    "                'Dataset1_half_toserver/Control_20','Dataset1_half_toserver/Control_21','Dataset1_half_toserver/Control_22',\n",
    "                'Dataset1_half_toserver/Control_23','Dataset1_half_toserver/Control_24'\n",
    "               ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.855909Z",
     "iopub.status.busy": "2023-10-10T10:21:39.855166Z",
     "iopub.status.idle": "2023-10-10T10:21:39.871337Z",
     "shell.execute_reply": "2023-10-10T10:21:39.870184Z"
    }
   },
   "outputs": [],
   "source": [
    "subject_dict = {\n",
    "                'Dataset1_half_toserver/PD_01' : 'PD_01_1','Dataset1_half_toserver/PD_02' : 'PD_02_1','Dataset1_half_toserver/PD_03' : 'PD_03_1',\n",
    "                'Dataset1_half_toserver/PD_04' : 'PD_04_1','Dataset1_half_toserver/PD_05' : 'PD_05_1','Dataset1_half_toserver/PD_06' : 'PD_06_1',\n",
    "                'Dataset1_half_toserver/PD_07' : 'PD_07_1','Dataset1_half_toserver/PD_08' : 'PD_08_1','Dataset1_half_toserver/PD_09' : 'PD_09_1',\n",
    "                'Dataset1_half_toserver/PD_10' : 'PD_10_1','Dataset1_half_toserver/PD_11' : 'PD_11_1','Dataset1_half_toserver/PD_12' : 'PD_12_1',\n",
    "                'Dataset1_half_toserver/PD_13' : 'PD_13_1','Dataset1_half_toserver/PD_14' : 'PD_14_1','Dataset1_half_toserver/PD_15' : 'PD_15_1',\n",
    "                'Dataset1_half_toserver/PD_16' : 'PD_16_1','Dataset1_half_toserver/PD_17' : 'PD_17_1','Dataset1_half_toserver/PD_18' : 'PD_18_1',\n",
    "                'Dataset1_half_toserver/PD_19' : 'PD_19_1','Dataset1_half_toserver/PD_20' : 'PD_20_1','Dataset1_half_toserver/PD_21' : 'PD_21_1',\n",
    "                'Dataset1_half_toserver/PD_22' : 'PD_22_1','Dataset1_half_toserver/PD_23' : 'PD_23_1','Dataset1_half_toserver/PD_24' : 'PD_24_1',\n",
    "                'Dataset1_half_toserver/PD_25' : 'PD_25_1',\n",
    "                'Dataset1_half_toserver/Control_01' : 'Control_01_1','Dataset1_half_toserver/Control_02' : 'Control_02_1',\n",
    "                'Dataset1_half_toserver/Control_03' : 'Control_03_1','Dataset1_half_toserver/Control_04' : 'Control_04_1',\n",
    "                'Dataset1_half_toserver/Control_05' : 'Control_05_1','Dataset1_half_toserver/Control_06' : 'Control_06_1',\n",
    "                'Dataset1_half_toserver/Control_07' : 'Control_07_1','Dataset1_half_toserver/Control_08' : 'Control_08_1',\n",
    "                'Dataset1_half_toserver/Control_09' : 'Control_09_1','Dataset1_half_toserver/Control_10' : 'Control_10_1',\n",
    "                'Dataset1_half_toserver/Control_11' : 'Control_11_1','Dataset1_half_toserver/Control_12' : 'Control_12_1',\n",
    "                'Dataset1_half_toserver/Control_13' : 'Control_13_1','Dataset1_half_toserver/Control_15' : 'Control_15_1',\n",
    "                'Dataset1_half_toserver/Control_16' : 'Control_16_1','Dataset1_half_toserver/Control_17' : 'Control_17_1',\n",
    "                'Dataset1_half_toserver/Control_18' : 'Control_18_1','Dataset1_half_toserver/Control_19' : 'Control_19_1',\n",
    "                'Dataset1_half_toserver/Control_20' : 'Control_20_1','Dataset1_half_toserver/Control_21' : 'Control_21_1',\n",
    "                'Dataset1_half_toserver/Control_22' : 'Control_22_1','Dataset1_half_toserver/Control_23' : 'Control_23_1',\n",
    "                'Dataset1_half_toserver/Control_24' : 'Control_24_1'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.878421Z",
     "iopub.status.busy": "2023-10-10T10:21:39.877912Z",
     "iopub.status.idle": "2023-10-10T10:21:39.890467Z",
     "shell.execute_reply": "2023-10-10T10:21:39.889084Z"
    },
    "id": "Guva6w0BPCuo"
   },
   "outputs": [],
   "source": [
    "def check_mistake_subjects(classifier,name):\n",
    "  name_arr = []\n",
    "  incorrect_arr = []\n",
    "  total_arr = []\n",
    "  percent_arr = []\n",
    "\n",
    "  for subject_name in subject_list:\n",
    "    correct = sum(subject_name in s for s in classifier[1])\n",
    "    incorrect = sum(subject_name in s for s in classifier[2])\n",
    "    total = correct + incorrect\n",
    "    if total != 0:\n",
    "      incorrect_percent = (incorrect/total)*100\n",
    "      name_arr.append(subject_dict.get(subject_name))\n",
    "      incorrect_arr.append(incorrect)\n",
    "      total_arr.append(total)\n",
    "      percent_arr.append(round(incorrect_percent,3))\n",
    "\n",
    "  matrix = np.array([name_arr,\n",
    "                        incorrect_arr,\n",
    "                        total_arr,\n",
    "                        percent_arr]).transpose()\n",
    "\n",
    "  df_report = pd.DataFrame(\n",
    "      data = matrix,\n",
    "      columns = ['Name', 'Incorrect Samples', 'Total Samples', 'Misclassification (%)']\n",
    "  ).set_index('Name')\n",
    "\n",
    "  df_report.to_csv(f'{name}.zip', index = True)\n",
    "  return df_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.895759Z",
     "iopub.status.busy": "2023-10-10T10:21:39.895309Z",
     "iopub.status.idle": "2023-10-10T10:21:39.903381Z",
     "shell.execute_reply": "2023-10-10T10:21:39.902045Z"
    }
   },
   "outputs": [],
   "source": [
    "x_df1.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.908248Z",
     "iopub.status.busy": "2023-10-10T10:21:39.907817Z",
     "iopub.status.idle": "2023-10-10T10:21:39.913723Z",
     "shell.execute_reply": "2023-10-10T10:21:39.911953Z"
    }
   },
   "outputs": [],
   "source": [
    "#sample = l1_feature_selection(test_label_5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df_test_5,y_df_test_5,x_df1.shape[1],param_grid1,'l1norm_rbf_0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.917747Z",
     "iopub.status.busy": "2023-10-10T10:21:39.917238Z",
     "iopub.status.idle": "2023-10-10T10:21:39.922625Z",
     "shell.execute_reply": "2023-10-10T10:21:39.921424Z"
    }
   },
   "outputs": [],
   "source": [
    "#sample_no_yhat = l1_feature_selection(test_label_5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df_test_5,y_df_test_5,x_df1.shape[1],param_grid1,'l1norm_rbf_0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.926732Z",
     "iopub.status.busy": "2023-10-10T10:21:39.926308Z",
     "iopub.status.idle": "2023-10-10T10:21:39.932693Z",
     "shell.execute_reply": "2023-10-10T10:21:39.930594Z"
    },
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "#sample2 = rfe(test_label_5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df_test_5,y_df_test_5,x_df1.shape[1],param_grid1,'rfe_0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.936808Z",
     "iopub.status.busy": "2023-10-10T10:21:39.936366Z",
     "iopub.status.idle": "2023-10-10T10:21:39.946992Z",
     "shell.execute_reply": "2023-10-10T10:21:39.945275Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = pd.DataFrame()\n",
    "\n",
    "df_best_val_score_l1 = pd.DataFrame()\n",
    "df_best_val_score_rfe = pd.DataFrame()\n",
    "\n",
    "df_best_c_l1 = pd.DataFrame()\n",
    "df_best_c_rfe = pd.DataFrame()\n",
    "\n",
    "df_best_gamma_l1 = pd.DataFrame()\n",
    "df_best_gamma_rfe = pd.DataFrame()\n",
    "\n",
    "l1norm_recall = ['L1_norm_recall']\n",
    "l1norm_f1 = ['L1_norm_f1']\n",
    "rfe_recall = ['RFE_recall']\n",
    "rfe_f1 = ['RFE_f1']\n",
    "\n",
    "l1_sel_feat_list = []\n",
    "rfe_sel_feat_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "execution": {
     "iopub.execute_input": "2023-10-10T10:21:39.950933Z",
     "iopub.status.busy": "2023-10-10T10:21:39.950493Z",
     "iopub.status.idle": "2023-10-10T10:25:02.144938Z",
     "shell.execute_reply": "2023-10-10T10:25:02.143253Z"
    },
    "id": "Ceep_if7Qj6r",
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "l1_1 = l1_feature_selection(test_label_5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df_test_5,y_df_test_5,x_df1.shape[1],param_grid2,'l1norm_rbf_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:25:02.156452Z",
     "iopub.status.busy": "2023-10-10T10:25:02.155814Z",
     "iopub.status.idle": "2023-10-10T10:25:02.164377Z",
     "shell.execute_reply": "2023-10-10T10:25:02.162619Z"
    }
   },
   "outputs": [],
   "source": [
    "l1norm_recall.append(l1_1[7])\n",
    "l1norm_f1.append(l1_1[8])\n",
    "l1_sel_feat_list.append(l1_1[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:25:02.168936Z",
     "iopub.status.busy": "2023-10-10T10:25:02.168491Z",
     "iopub.status.idle": "2023-10-10T10:25:02.189077Z",
     "shell.execute_reply": "2023-10-10T10:25:02.187687Z"
    },
    "id": "Klpt2hqdPNr5"
   },
   "outputs": [],
   "source": [
    "cms1 = check_mistake_subjects(l1_1,'L1_1')\n",
    "cms1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:25:02.196383Z",
     "iopub.status.busy": "2023-10-10T10:25:02.195708Z",
     "iopub.status.idle": "2023-10-10T10:25:02.473176Z",
     "shell.execute_reply": "2023-10-10T10:25:02.471731Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(l1_1[0])\n",
    "df_best_val_score_l1 = df_best_val_score_l1.append(l1_1[3])\n",
    "df_best_c_l1 = df_best_c_l1.append(l1_1[4])\n",
    "df_best_gamma_l1 = df_best_gamma_l1.append(l1_1[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "execution": {
     "iopub.execute_input": "2023-10-10T10:25:02.482557Z",
     "iopub.status.busy": "2023-10-10T10:25:02.482040Z",
     "iopub.status.idle": "2023-10-10T10:28:22.061996Z",
     "shell.execute_reply": "2023-10-10T10:28:22.061040Z"
    },
    "id": "iFhO6TBC2_D6"
   },
   "outputs": [],
   "source": [
    "l1_2 = l1_feature_selection(test_label_1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df5,y_df5,x_df_test_1,y_df_test_1,x_df1.shape[1],param_grid2,'l1norm_rbf_2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:28:22.071038Z",
     "iopub.status.busy": "2023-10-10T10:28:22.070573Z",
     "iopub.status.idle": "2023-10-10T10:28:22.075895Z",
     "shell.execute_reply": "2023-10-10T10:28:22.075087Z"
    }
   },
   "outputs": [],
   "source": [
    "l1norm_recall.append(l1_2[7])\n",
    "l1norm_f1.append(l1_2[8])\n",
    "l1_sel_feat_list.append(l1_2[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:28:22.080969Z",
     "iopub.status.busy": "2023-10-10T10:28:22.080579Z",
     "iopub.status.idle": "2023-10-10T10:28:22.096186Z",
     "shell.execute_reply": "2023-10-10T10:28:22.095361Z"
    },
    "id": "NI3kwr5f4Qit"
   },
   "outputs": [],
   "source": [
    "cms2 = check_mistake_subjects(l1_2,'L1_2')\n",
    "cms2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:28:22.100562Z",
     "iopub.status.busy": "2023-10-10T10:28:22.100095Z",
     "iopub.status.idle": "2023-10-10T10:28:22.161639Z",
     "shell.execute_reply": "2023-10-10T10:28:22.160813Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(l1_2[0])\n",
    "df_best_val_score_l1 = df_best_val_score_l1.append(l1_2[3])\n",
    "df_best_c_l1 = df_best_c_l1.append(l1_2[4])\n",
    "df_best_gamma_l1 = df_best_gamma_l1.append(l1_2[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "execution": {
     "iopub.execute_input": "2023-10-10T10:28:22.170987Z",
     "iopub.status.busy": "2023-10-10T10:28:22.170522Z",
     "iopub.status.idle": "2023-10-10T10:31:42.229019Z",
     "shell.execute_reply": "2023-10-10T10:31:42.227557Z"
    },
    "id": "13AHnih22_VJ"
   },
   "outputs": [],
   "source": [
    "l1_3 = l1_feature_selection(test_label_2,x_df3,y_df3,x_df4,y_df4,x_df5,y_df5,x_df1,y_df1,x_df_test_2,y_df_test_2,x_df1.shape[1],param_grid2,'l1norm_rbf_3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:31:42.236461Z",
     "iopub.status.busy": "2023-10-10T10:31:42.235967Z",
     "iopub.status.idle": "2023-10-10T10:31:42.243060Z",
     "shell.execute_reply": "2023-10-10T10:31:42.241670Z"
    }
   },
   "outputs": [],
   "source": [
    "l1norm_recall.append(l1_3[7])\n",
    "l1norm_f1.append(l1_3[8])\n",
    "l1_sel_feat_list.append(l1_3[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:31:42.247804Z",
     "iopub.status.busy": "2023-10-10T10:31:42.247392Z",
     "iopub.status.idle": "2023-10-10T10:31:42.265866Z",
     "shell.execute_reply": "2023-10-10T10:31:42.264537Z"
    },
    "id": "DhRhZdTr4Q0R"
   },
   "outputs": [],
   "source": [
    "cms3 = check_mistake_subjects(l1_3,'L1_3')\n",
    "cms3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:31:42.271427Z",
     "iopub.status.busy": "2023-10-10T10:31:42.270977Z",
     "iopub.status.idle": "2023-10-10T10:31:42.339564Z",
     "shell.execute_reply": "2023-10-10T10:31:42.338036Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(l1_3[0])\n",
    "df_best_val_score_l1 = df_best_val_score_l1.append(l1_3[3])\n",
    "df_best_c_l1 = df_best_c_l1.append(l1_3[4])\n",
    "df_best_gamma_l1 = df_best_gamma_l1.append(l1_3[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "execution": {
     "iopub.execute_input": "2023-10-10T10:31:42.347954Z",
     "iopub.status.busy": "2023-10-10T10:31:42.347460Z",
     "iopub.status.idle": "2023-10-10T10:34:59.471614Z",
     "shell.execute_reply": "2023-10-10T10:34:59.470099Z"
    },
    "id": "2_5L-ggD2_i3"
   },
   "outputs": [],
   "source": [
    "l1_4 = l1_feature_selection(test_label_3,x_df4,y_df4,x_df5,y_df5,x_df1,y_df1,x_df2,y_df2,x_df_test_3,y_df_test_3,x_df1.shape[1],param_grid2,'l1norm_rbf_4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:34:59.479732Z",
     "iopub.status.busy": "2023-10-10T10:34:59.479233Z",
     "iopub.status.idle": "2023-10-10T10:34:59.486575Z",
     "shell.execute_reply": "2023-10-10T10:34:59.485013Z"
    }
   },
   "outputs": [],
   "source": [
    "l1norm_recall.append(l1_4[7])\n",
    "l1norm_f1.append(l1_4[8])\n",
    "l1_sel_feat_list.append(l1_4[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:34:59.491974Z",
     "iopub.status.busy": "2023-10-10T10:34:59.491419Z",
     "iopub.status.idle": "2023-10-10T10:34:59.511798Z",
     "shell.execute_reply": "2023-10-10T10:34:59.510640Z"
    },
    "id": "f9kccCjT4RB7"
   },
   "outputs": [],
   "source": [
    "cms4 = check_mistake_subjects(l1_4,'L1_4')\n",
    "cms4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:34:59.517136Z",
     "iopub.status.busy": "2023-10-10T10:34:59.516681Z",
     "iopub.status.idle": "2023-10-10T10:34:59.575327Z",
     "shell.execute_reply": "2023-10-10T10:34:59.573902Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(l1_4[0])\n",
    "df_best_val_score_l1 = df_best_val_score_l1.append(l1_4[3])\n",
    "df_best_c_l1 = df_best_c_l1.append(l1_4[4])\n",
    "df_best_gamma_l1 = df_best_gamma_l1.append(l1_4[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "background_save": true
    },
    "execution": {
     "iopub.execute_input": "2023-10-10T10:34:59.583516Z",
     "iopub.status.busy": "2023-10-10T10:34:59.583072Z",
     "iopub.status.idle": "2023-10-10T10:38:13.390940Z",
     "shell.execute_reply": "2023-10-10T10:38:13.389470Z"
    },
    "id": "LZ3KGiou2_w7"
   },
   "outputs": [],
   "source": [
    "l1_5 = l1_feature_selection(test_label_4,x_df5,y_df5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df_test_4,y_df_test_4,x_df1.shape[1],param_grid2,'l1norm_rbf_5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.397759Z",
     "iopub.status.busy": "2023-10-10T10:38:13.397248Z",
     "iopub.status.idle": "2023-10-10T10:38:13.405197Z",
     "shell.execute_reply": "2023-10-10T10:38:13.403112Z"
    }
   },
   "outputs": [],
   "source": [
    "l1norm_recall.append(l1_5[7])\n",
    "l1norm_f1.append(l1_5[8])\n",
    "l1_sel_feat_list.append(l1_5[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.412339Z",
     "iopub.status.busy": "2023-10-10T10:38:13.411537Z",
     "iopub.status.idle": "2023-10-10T10:38:13.437681Z",
     "shell.execute_reply": "2023-10-10T10:38:13.436323Z"
    },
    "id": "MSsV5Erf4RnU"
   },
   "outputs": [],
   "source": [
    "cms5 = check_mistake_subjects(l1_5,'L1_5')\n",
    "cms5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.443553Z",
     "iopub.status.busy": "2023-10-10T10:38:13.443064Z",
     "iopub.status.idle": "2023-10-10T10:38:13.673394Z",
     "shell.execute_reply": "2023-10-10T10:38:13.671959Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(l1_5[0])\n",
    "df_best_val_score_l1 = df_best_val_score_l1.append(l1_5[3])\n",
    "df_best_c_l1 = df_best_c_l1.append(l1_5[4])\n",
    "df_best_gamma_l1 = df_best_gamma_l1.append(l1_5[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.683114Z",
     "iopub.status.busy": "2023-10-10T10:38:13.682618Z",
     "iopub.status.idle": "2023-10-10T10:38:13.695247Z",
     "shell.execute_reply": "2023-10-10T10:38:13.693578Z"
    }
   },
   "outputs": [],
   "source": [
    "def f1_allplot(x1,y1,label1,x2,y2,label2,x3,y3,label3,x4,y4,label4,x5,y5,label5):\n",
    "  plt.plot(x1,y1, label = label1)\n",
    "  plt.plot(x2,y2, label = label2)\n",
    "  plt.plot(x3,y3, label = label3)\n",
    "  plt.plot(x4,y4, label = label4)\n",
    "  plt.plot(x5,y5, label = label5)\n",
    "  plt.title('F1-macro score in each iteration of feature selection process')\n",
    "  plt.xlabel('Number of features used')\n",
    "  plt.ylabel('Score')\n",
    "  plt.legend(loc='best')\n",
    "  plt.grid(axis = 'x')\n",
    "  plt.show()\n",
    "\n",
    "x_range = np.linspace(1,x_df1.shape[1],x_df1.shape[1],endpoint =True,dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.701214Z",
     "iopub.status.busy": "2023-10-10T10:38:13.700748Z",
     "iopub.status.idle": "2023-10-10T10:38:13.939411Z",
     "shell.execute_reply": "2023-10-10T10:38:13.938175Z"
    }
   },
   "outputs": [],
   "source": [
    "f1_allplot(\n",
    "    x_range, l1_1[6],'L1_1',\n",
    "    x_range, l1_2[6], 'L1_2',\n",
    "    x_range, l1_3[6],'L1_3',\n",
    "    x_range, l1_4[6],'L1_4',\n",
    "    x_range, l1_5[6],'L1_5'    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:38:13.949549Z",
     "iopub.status.busy": "2023-10-10T10:38:13.949049Z",
     "iopub.status.idle": "2023-10-10T10:41:31.887488Z",
     "shell.execute_reply": "2023-10-10T10:41:31.885902Z"
    },
    "id": "b3T1iJwvQqgH"
   },
   "outputs": [],
   "source": [
    "rfe_1 = rfe(test_label_5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df_test_5,y_df_test_5,x_df1.shape[1],param_grid2,'rfe_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:31.896116Z",
     "iopub.status.busy": "2023-10-10T10:41:31.895755Z",
     "iopub.status.idle": "2023-10-10T10:41:31.903046Z",
     "shell.execute_reply": "2023-10-10T10:41:31.901699Z"
    }
   },
   "outputs": [],
   "source": [
    "rfe_recall.append(rfe_1[7])\n",
    "rfe_f1.append(rfe_1[8])\n",
    "rfe_sel_feat_list.append(rfe_1[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:31.911957Z",
     "iopub.status.busy": "2023-10-10T10:41:31.911339Z",
     "iopub.status.idle": "2023-10-10T10:41:31.931925Z",
     "shell.execute_reply": "2023-10-10T10:41:31.930384Z"
    },
    "id": "OJGZ1q6z4b0l"
   },
   "outputs": [],
   "source": [
    "cms1_r = check_mistake_subjects(rfe_1,'rfe_1')\n",
    "cms1_r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:31.939100Z",
     "iopub.status.busy": "2023-10-10T10:41:31.938661Z",
     "iopub.status.idle": "2023-10-10T10:41:31.948479Z",
     "shell.execute_reply": "2023-10-10T10:41:31.946903Z"
    }
   },
   "outputs": [],
   "source": [
    "def cms_summary(l1,rfe,name):\n",
    "    df = pd.concat([l1,rfe],axis=1)\n",
    "    df.columns = pd.MultiIndex.from_tuples(\n",
    "    zip(['','L1_norm','','','RFE',''],\n",
    "       df.columns)\n",
    "    )\n",
    "    df.to_csv(f'{name}.csv')\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:31.953092Z",
     "iopub.status.busy": "2023-10-10T10:41:31.952652Z",
     "iopub.status.idle": "2023-10-10T10:41:31.985224Z",
     "shell.execute_reply": "2023-10-10T10:41:31.983670Z"
    }
   },
   "outputs": [],
   "source": [
    "cms_summary(cms1,cms1_r,'09102023_final_reports/Classifying mistakes summary #1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:31.990609Z",
     "iopub.status.busy": "2023-10-10T10:41:31.990181Z",
     "iopub.status.idle": "2023-10-10T10:41:32.076916Z",
     "shell.execute_reply": "2023-10-10T10:41:32.075409Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(rfe_1[0])\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.append(rfe_1[3])\n",
    "df_best_c_rfe = df_best_c_rfe.append(rfe_1[4])\n",
    "df_best_gamma_rfe = df_best_gamma_rfe.append(rfe_1[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:41:32.086061Z",
     "iopub.status.busy": "2023-10-10T10:41:32.085539Z",
     "iopub.status.idle": "2023-10-10T10:44:48.864808Z",
     "shell.execute_reply": "2023-10-10T10:44:48.863025Z"
    },
    "id": "A7JBDQjC3yRH"
   },
   "outputs": [],
   "source": [
    "rfe_2 = rfe(test_label_1,x_df2,y_df2,x_df3,y_df3,x_df4,y_df4,x_df5,y_df5,x_df_test_1,y_df_test_1,x_df1.shape[1],param_grid2,'rfe_2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:44:48.871655Z",
     "iopub.status.busy": "2023-10-10T10:44:48.871105Z",
     "iopub.status.idle": "2023-10-10T10:44:48.878563Z",
     "shell.execute_reply": "2023-10-10T10:44:48.877084Z"
    }
   },
   "outputs": [],
   "source": [
    "rfe_recall.append(rfe_2[7])\n",
    "rfe_f1.append(rfe_2[8])\n",
    "rfe_sel_feat_list.append(rfe_2[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:44:48.884091Z",
     "iopub.status.busy": "2023-10-10T10:44:48.883614Z",
     "iopub.status.idle": "2023-10-10T10:44:48.903094Z",
     "shell.execute_reply": "2023-10-10T10:44:48.901761Z"
    },
    "id": "yJmECXYn4ffk"
   },
   "outputs": [],
   "source": [
    "cms2_r = check_mistake_subjects(rfe_2,'rfe_2')\n",
    "cms2_r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:44:48.908231Z",
     "iopub.status.busy": "2023-10-10T10:44:48.907744Z",
     "iopub.status.idle": "2023-10-10T10:44:48.929382Z",
     "shell.execute_reply": "2023-10-10T10:44:48.928006Z"
    }
   },
   "outputs": [],
   "source": [
    "cms_summary(cms2,cms2_r,'09102023_final_reports/Classifying mistakes summary #2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:44:48.935580Z",
     "iopub.status.busy": "2023-10-10T10:44:48.935115Z",
     "iopub.status.idle": "2023-10-10T10:44:49.014651Z",
     "shell.execute_reply": "2023-10-10T10:44:49.013235Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(rfe_2[0])\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.append(rfe_2[3])\n",
    "df_best_c_rfe = df_best_c_rfe.append(rfe_2[4])\n",
    "df_best_gamma_rfe = df_best_gamma_rfe.append(rfe_2[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:44:49.019896Z",
     "iopub.status.busy": "2023-10-10T10:44:49.019443Z",
     "iopub.status.idle": "2023-10-10T10:48:10.029110Z",
     "shell.execute_reply": "2023-10-10T10:48:10.028110Z"
    },
    "id": "V_E7GC9S3zdM"
   },
   "outputs": [],
   "source": [
    "rfe_3 = rfe(test_label_2,x_df3,y_df3,x_df4,y_df4,x_df5,y_df5,x_df1,y_df1,x_df_test_2,y_df_test_2,x_df1.shape[1],param_grid2,'rfe_3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:48:10.037645Z",
     "iopub.status.busy": "2023-10-10T10:48:10.037247Z",
     "iopub.status.idle": "2023-10-10T10:48:10.043078Z",
     "shell.execute_reply": "2023-10-10T10:48:10.041918Z"
    }
   },
   "outputs": [],
   "source": [
    "rfe_recall.append(rfe_3[7])\n",
    "rfe_f1.append(rfe_3[8])\n",
    "rfe_sel_feat_list.append(rfe_3[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:48:10.047611Z",
     "iopub.status.busy": "2023-10-10T10:48:10.047276Z",
     "iopub.status.idle": "2023-10-10T10:48:10.064480Z",
     "shell.execute_reply": "2023-10-10T10:48:10.063136Z"
    },
    "id": "1l0blYwr4f70"
   },
   "outputs": [],
   "source": [
    "cms3_r = check_mistake_subjects(rfe_3,'rfe_3')\n",
    "cms3_r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:48:10.069001Z",
     "iopub.status.busy": "2023-10-10T10:48:10.068709Z",
     "iopub.status.idle": "2023-10-10T10:48:10.087705Z",
     "shell.execute_reply": "2023-10-10T10:48:10.086369Z"
    }
   },
   "outputs": [],
   "source": [
    "cms_summary(cms3,cms3_r,'09102023_final_reports/Classifying mistakes summary #3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:48:10.094606Z",
     "iopub.status.busy": "2023-10-10T10:48:10.094313Z",
     "iopub.status.idle": "2023-10-10T10:48:10.151359Z",
     "shell.execute_reply": "2023-10-10T10:48:10.149991Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(rfe_3[0])\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.append(rfe_3[3])\n",
    "df_best_c_rfe = df_best_c_rfe.append(rfe_3[4])\n",
    "df_best_gamma_rfe = df_best_gamma_rfe.append(rfe_3[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:48:10.159027Z",
     "iopub.status.busy": "2023-10-10T10:48:10.158728Z",
     "iopub.status.idle": "2023-10-10T10:51:23.536575Z",
     "shell.execute_reply": "2023-10-10T10:51:23.535378Z"
    },
    "id": "DJWadnVT30Yk"
   },
   "outputs": [],
   "source": [
    "rfe_4 = rfe(test_label_3,x_df4,y_df4,x_df5,y_df5,x_df1,y_df1,x_df2,y_df2,x_df_test_3,y_df_test_3,x_df1.shape[1],param_grid2,'rfe_4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:51:23.544608Z",
     "iopub.status.busy": "2023-10-10T10:51:23.544184Z",
     "iopub.status.idle": "2023-10-10T10:51:23.550116Z",
     "shell.execute_reply": "2023-10-10T10:51:23.548917Z"
    }
   },
   "outputs": [],
   "source": [
    "rfe_recall.append(rfe_4[7])\n",
    "rfe_f1.append(rfe_4[8])\n",
    "rfe_sel_feat_list.append(rfe_4[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:51:23.554936Z",
     "iopub.status.busy": "2023-10-10T10:51:23.554588Z",
     "iopub.status.idle": "2023-10-10T10:51:23.572656Z",
     "shell.execute_reply": "2023-10-10T10:51:23.571298Z"
    },
    "id": "NI9kLaLA4gTg"
   },
   "outputs": [],
   "source": [
    "cms4_r = check_mistake_subjects(rfe_4,'rfe_4')\n",
    "cms4_r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:51:23.577516Z",
     "iopub.status.busy": "2023-10-10T10:51:23.577129Z",
     "iopub.status.idle": "2023-10-10T10:51:23.598227Z",
     "shell.execute_reply": "2023-10-10T10:51:23.596880Z"
    }
   },
   "outputs": [],
   "source": [
    "cms_summary(cms4,cms4_r,'09102023_final_reports/Classifying mistakes summary #4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:51:23.604362Z",
     "iopub.status.busy": "2023-10-10T10:51:23.603962Z",
     "iopub.status.idle": "2023-10-10T10:51:23.664507Z",
     "shell.execute_reply": "2023-10-10T10:51:23.663001Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(rfe_4[0])\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.append(rfe_4[3])\n",
    "df_best_c_rfe = df_best_c_rfe.append(rfe_4[4])\n",
    "df_best_gamma_rfe = df_best_gamma_rfe.append(rfe_4[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:51:23.673703Z",
     "iopub.status.busy": "2023-10-10T10:51:23.673311Z",
     "iopub.status.idle": "2023-10-10T10:54:38.789907Z",
     "shell.execute_reply": "2023-10-10T10:54:38.788637Z"
    },
    "id": "FpMHpsaG31as"
   },
   "outputs": [],
   "source": [
    "rfe_5 = rfe(test_label_4,x_df5,y_df5,x_df1,y_df1,x_df2,y_df2,x_df3,y_df3,x_df_test_4,y_df_test_4,x_df1.shape[1],param_grid2,'rfe_5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:38.799567Z",
     "iopub.status.busy": "2023-10-10T10:54:38.799158Z",
     "iopub.status.idle": "2023-10-10T10:54:38.805725Z",
     "shell.execute_reply": "2023-10-10T10:54:38.804741Z"
    }
   },
   "outputs": [],
   "source": [
    "rfe_recall.append(rfe_5[7])\n",
    "rfe_f1.append(rfe_5[8])\n",
    "rfe_sel_feat_list.append(rfe_5[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:38.809877Z",
     "iopub.status.busy": "2023-10-10T10:54:38.809426Z",
     "iopub.status.idle": "2023-10-10T10:54:38.825302Z",
     "shell.execute_reply": "2023-10-10T10:54:38.824261Z"
    },
    "id": "DOIwnuDx4gin"
   },
   "outputs": [],
   "source": [
    "cms5_r = check_mistake_subjects(rfe_5,'rfe_5')\n",
    "cms5_r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:38.829732Z",
     "iopub.status.busy": "2023-10-10T10:54:38.829281Z",
     "iopub.status.idle": "2023-10-10T10:54:38.847337Z",
     "shell.execute_reply": "2023-10-10T10:54:38.846369Z"
    }
   },
   "outputs": [],
   "source": [
    "cms_summary(cms5,cms5_r,'09102023_final_reports/Classifying mistakes summary #5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:38.852392Z",
     "iopub.status.busy": "2023-10-10T10:54:38.851944Z",
     "iopub.status.idle": "2023-10-10T10:54:38.910771Z",
     "shell.execute_reply": "2023-10-10T10:54:38.909572Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.append(rfe_5[0])\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.append(rfe_5[3])\n",
    "df_best_c_rfe = df_best_c_rfe.append(rfe_5[4])\n",
    "df_best_gamma_rfe = df_best_gamma_rfe.append(rfe_5[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:38.919927Z",
     "iopub.status.busy": "2023-10-10T10:54:38.919441Z",
     "iopub.status.idle": "2023-10-10T10:54:39.128526Z",
     "shell.execute_reply": "2023-10-10T10:54:39.127059Z"
    }
   },
   "outputs": [],
   "source": [
    "f1_allplot(\n",
    "    x_range, rfe_1[6],'rfe_1',\n",
    "    x_range, rfe_2[6], 'rfe_2',\n",
    "    x_range, rfe_3[6],'rfe_3',\n",
    "    x_range, rfe_4[6],'rfe_4',\n",
    "    x_range, rfe_5[6],'rfe_5'    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.139939Z",
     "iopub.status.busy": "2023-10-10T10:54:39.139430Z",
     "iopub.status.idle": "2023-10-10T10:54:39.158409Z",
     "shell.execute_reply": "2023-10-10T10:54:39.157303Z"
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.162986Z",
     "iopub.status.busy": "2023-10-10T10:54:39.162583Z",
     "iopub.status.idle": "2023-10-10T10:54:39.182522Z",
     "shell.execute_reply": "2023-10-10T10:54:39.181065Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.190820Z",
     "iopub.status.busy": "2023-10-10T10:54:39.190327Z",
     "iopub.status.idle": "2023-10-10T10:54:39.212059Z",
     "shell.execute_reply": "2023-10-10T10:54:39.210833Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_rfe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.217102Z",
     "iopub.status.busy": "2023-10-10T10:54:39.216679Z",
     "iopub.status.idle": "2023-10-10T10:54:39.221539Z",
     "shell.execute_reply": "2023-10-10T10:54:39.220774Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset_col = ['Algorithm','Dataset 1','Dataset 2','Dataset 3','Dataset 4','Dataset 5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.225350Z",
     "iopub.status.busy": "2023-10-10T10:54:39.224908Z",
     "iopub.status.idle": "2023-10-10T10:54:39.231066Z",
     "shell.execute_reply": "2023-10-10T10:54:39.230303Z"
    }
   },
   "outputs": [],
   "source": [
    "df_recall = pd.DataFrame(data = [l1norm_recall, rfe_recall],\n",
    "                        columns = dataset_col).set_index(['Algorithm'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.234626Z",
     "iopub.status.busy": "2023-10-10T10:54:39.234179Z",
     "iopub.status.idle": "2023-10-10T10:54:39.239938Z",
     "shell.execute_reply": "2023-10-10T10:54:39.239118Z"
    }
   },
   "outputs": [],
   "source": [
    "df_f1 = pd.DataFrame(data = [l1norm_f1, rfe_f1],\n",
    "                    columns = dataset_col).set_index(['Algorithm'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.243463Z",
     "iopub.status.busy": "2023-10-10T10:54:39.243014Z",
     "iopub.status.idle": "2023-10-10T10:54:39.507573Z",
     "shell.execute_reply": "2023-10-10T10:54:39.506303Z"
    }
   },
   "outputs": [],
   "source": [
    "df_recall['mean'] = df_recall.mean(axis=1)\n",
    "df_recall = df_recall.style.highlight_max(color = 'pink',axis =0)\n",
    "df_recall.to_excel('09102023_final_reports/recall.xlsx')\n",
    "df_recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.517171Z",
     "iopub.status.busy": "2023-10-10T10:54:39.516631Z",
     "iopub.status.idle": "2023-10-10T10:54:39.545768Z",
     "shell.execute_reply": "2023-10-10T10:54:39.544546Z"
    }
   },
   "outputs": [],
   "source": [
    "df_f1['mean'] = df_f1.mean(axis=1)\n",
    "df_f1 = df_f1.style.highlight_max(color = 'lightblue',axis =0)\n",
    "df_f1.to_excel('09102023_final_reports/f1.xlsx')\n",
    "df_f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.554883Z",
     "iopub.status.busy": "2023-10-10T10:54:39.554402Z",
     "iopub.status.idle": "2023-10-10T10:54:39.560080Z",
     "shell.execute_reply": "2023-10-10T10:54:39.558837Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.564765Z",
     "iopub.status.busy": "2023-10-10T10:54:39.564275Z",
     "iopub.status.idle": "2023-10-10T10:54:39.573824Z",
     "shell.execute_reply": "2023-10-10T10:54:39.572803Z"
    }
   },
   "outputs": [],
   "source": [
    "def sel_feat_count(sel_feat_list):\n",
    "    counter_list = []\n",
    "    for i in sel_feat_list:\n",
    "        counter_list.append(Counter(i))\n",
    "        \n",
    "    return sum(counter_list, Counter())\n",
    "\n",
    "def sel_feat_count_df(l1,rfe):\n",
    "    l1_count = sel_feat_count(l1_sel_feat_list)\n",
    "    rfe_count = sel_feat_count(rfe_sel_feat_list)\n",
    "    one = pd.DataFrame.from_dict(l1_count, columns = ['l1_count'], orient='index').transpose()\n",
    "    two = pd.DataFrame.from_dict(rfe_count,columns = ['rfe_count'], orient='index').transpose()\n",
    "    one = one.append(two).fillna(int(0))\n",
    "    one.to_csv('09102023_final_reports/selected_feature_count.csv')\n",
    "    return one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.578395Z",
     "iopub.status.busy": "2023-10-10T10:54:39.577767Z",
     "iopub.status.idle": "2023-10-10T10:54:39.635843Z",
     "shell.execute_reply": "2023-10-10T10:54:39.634587Z"
    }
   },
   "outputs": [],
   "source": [
    "sel_feat_count_df(l1_sel_feat_list, rfe_sel_feat_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.644245Z",
     "iopub.status.busy": "2023-10-10T10:54:39.643798Z",
     "iopub.status.idle": "2023-10-10T10:54:39.649455Z",
     "shell.execute_reply": "2023-10-10T10:54:39.648411Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_l1 = df_best_val_score_l1.style.highlight_max(color = 'pink',axis =1)\n",
    "df_best_val_score_rfe = df_best_val_score_rfe.style.highlight_max(color = 'pink',axis =1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.653567Z",
     "iopub.status.busy": "2023-10-10T10:54:39.653114Z",
     "iopub.status.idle": "2023-10-10T10:54:39.668365Z",
     "shell.execute_reply": "2023-10-10T10:54:39.667426Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.672820Z",
     "iopub.status.busy": "2023-10-10T10:54:39.672376Z",
     "iopub.status.idle": "2023-10-10T10:54:39.686293Z",
     "shell.execute_reply": "2023-10-10T10:54:39.685379Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_rfe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.690309Z",
     "iopub.status.busy": "2023-10-10T10:54:39.689942Z",
     "iopub.status.idle": "2023-10-10T10:54:39.736366Z",
     "shell.execute_reply": "2023-10-10T10:54:39.735284Z"
    }
   },
   "outputs": [],
   "source": [
    "df_best_val_score_l1.to_excel('09102023_final_reports/best_score_l1.xlsx')\n",
    "df_best_val_score_rfe.to_excel('09102023_final_reports/best_score_rfe.xlsx')\n",
    "\n",
    "df_best_c_l1.to_csv('09102023_final_reports/best_c_l1.csv')\n",
    "df_best_c_rfe.to_csv('09102023_final_reports/best_c_rfe.csv')\n",
    "\n",
    "df_best_gamma_l1.to_csv('09102023_final_reports/best_gamma_l1.csv')\n",
    "df_best_gamma_rfe.to_csv('09102023_final_reports/best_gamma_rfe.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.743518Z",
     "iopub.status.busy": "2023-10-10T10:54:39.743055Z",
     "iopub.status.idle": "2023-10-10T10:54:39.764608Z",
     "shell.execute_reply": "2023-10-10T10:54:39.763435Z"
    },
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "df_all_feature_count = df_all_feature_count.transpose()\n",
    "df_all_feature_count['average'] =df_all_feature_count.mean(axis=0)\n",
    "df_all_feature_count = df_all_feature_count.sort_values(by = ['average'],ascending=False)\n",
    "df_all_feature_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.775453Z",
     "iopub.status.busy": "2023-10-10T10:54:39.775021Z",
     "iopub.status.idle": "2023-10-10T10:54:39.809828Z",
     "shell.execute_reply": "2023-10-10T10:54:39.808811Z"
    }
   },
   "outputs": [],
   "source": [
    "feat_count_l1 = df_all_feature_count[['l1norm_rbf_1','l1norm_rbf_2','l1norm_rbf_3','l1norm_rbf_4', 'l1norm_rbf_5']]\n",
    "feat_count_l1['avg'] = feat_count_l1.mean(axis=1)\n",
    "feat_count_l1 = feat_count_l1.sort_values(by = ['avg'],ascending=False)\n",
    "feat_count_l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.817722Z",
     "iopub.status.busy": "2023-10-10T10:54:39.817357Z",
     "iopub.status.idle": "2023-10-10T10:54:39.846991Z",
     "shell.execute_reply": "2023-10-10T10:54:39.845982Z"
    }
   },
   "outputs": [],
   "source": [
    "feat_count_rfe = df_all_feature_count[['rfe_1','rfe_2','rfe_3','rfe_4', 'rfe_5']]\n",
    "feat_count_rfe['avg'] = feat_count_rfe.mean(axis=1)\n",
    "feat_count_rfe = feat_count_rfe.sort_values(by = ['avg'],ascending=False)\n",
    "feat_count_rfe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-10-10T10:54:39.855227Z",
     "iopub.status.busy": "2023-10-10T10:54:39.854803Z",
     "iopub.status.idle": "2023-10-10T10:54:39.860871Z",
     "shell.execute_reply": "2023-10-10T10:54:39.860152Z"
    }
   },
   "outputs": [],
   "source": [
    "feat_count_l1.to_csv('09102023_final_reports/features_count_l1.csv')\n",
    "feat_count_rfe.to_csv('09102023_final_reports/features_count_rfe.csv')"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}