benchmark/numpy_13/numpy_13_fixed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Music?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first lesson of Popular Music History lecture, a professor came and asked us \"What is Music?\". We all had different answers. Music is a song made by instruments. Music is the expression of feelings. Music is singing. Music is what takes us to other worlds. The answers were all correct. However, the professor said there was a more general definition. Music is a set of sounds that harmonize with each other. It is harmony that distinguishes music from noise.\n",
    "\n",
    "Popular Music History was one of the elective courses I took during my engineering degree. After many years, I never forgot this answer from the professor. It was very reasonable. Above all, musical notes we hear from different instruments are just sound waves. They have mathematical expressions in both the time and frequency domain. Some waves go well with each other. Some just don't get along and make noise.\n",
    "\n",
    "Recently, I was searching for datasets about music in Kaggle and came across [Deep Contractor's](https://www.kaggle.com/deepcontractor) dataset \"[Musical Instrument Chord Classification (Audio)](https://www.kaggle.com/deepcontractor/musical-instrument-chord-classification)\". The dataset contains audio files which are chord recordings from either a piano or guitar. Chords are labeled as Major or Minor, so the data is suitable for a classification problem. I thought why not give it a try and started.\n",
    "\n",
    "In the first section, I explained the mathematics behind the music as much as I can. There will be a bit of music theory, a bit of math, and a bit of digital signal processing. Using the knowledge from section 1, I created a DataFrame from all the audio files in section 2. In section 3, I explored data and applied some feature engineering to make it ready for machine learning. Finally, I build a model and make predictions in section 4. \n",
    "\n",
    "**Index**\n",
    "\n",
    "1. [Understanding Math Behind Music](#1.-Understanding-Math-Behind-Music)\n",
    "\n",
    " 1.1. [Notes and Chords](#1.1.-Notes-and-Chords)\n",
    " \n",
    " 1.2. [Time and Frequency Domain Representations](#1.2.-Time-and-Frequency-Domain-Representations)\n",
    " \n",
    " 1.3. [Spectrogram](#1.3.-Spectrogram)\n",
    " \n",
    " 1.4. [Detection of Harmonic Frequencies](#1.4.-Detection-of-Harmonic-Frequencies)\n",
    "\n",
    "2. [Importing Dataset](#2.-Importing-Dataset)\n",
    "\n",
    "3. [Data Exploration](#3.-Data-Exploration)\n",
    "\n",
    " 3.1. [Min and Max Harmonics](#3.1.-Min-and-Max-Harmonics)\n",
    " \n",
    " 3.2. [Number of Harmonics](#3.2.-Number-of-Harmonics)\n",
    " \n",
    " 3.3. [Feature Engineering on Harmonics](#3.3.-Feature-Engineering-on-Harmonics)\n",
    "\n",
    "4. [Model Building](#4.-Model-Building)\n",
    "\n",
    " 4.1. [Preprocessing Data](#4.1.-Preprocessing-Data)\n",
    " \n",
    " 4.2. [Model Selection](#4.2.-Model-Selection)\n",
    " \n",
    " 4.3. [Model Training and Prediction](#4.3.-Model-Training-and-Prediction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Understanding Math Behind Music"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:50.439036Z",
     "iopub.status.busy": "2023-04-24T19:47:50.438637Z",
     "iopub.status.idle": "2023-04-24T19:47:51.679073Z",
     "shell.execute_reply": "2023-04-24T19:47:51.678228Z",
     "shell.execute_reply.started": "2023-04-24T19:47:50.438964Z"
    }
   },
   "outputs": [],
   "source": [
    "# importing necessary packages for the section\n",
    "import os\n",
    "import IPython\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.io import wavfile\n",
    "from scipy.fft import fft, fftfreq\n",
    "from scipy.signal import spectrogram, find_peaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1. Notes and Chords"
   ]
  },
  {
   "attachments": {
    "b6f37314-e253-479a-b37c-9296e4ca19b8.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAAFfCAYAAAAGdKYmAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAACrISURBVHhe7d0JvF3TvQfwFWJWlBqLkqjEUFNFayo1K6+eDoZSLaq84rXhqakorT5DS5DSR7Q8UTWU57VPgtKkMfUh5jZFzDE8YoiYidf/zrrJzc2lyb3rnpNz9/f7+ZxP9lrk5N5z9973rN9Z67/6jBkz5v0EAAAAAN00V/4TAAAAALpF0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFBEnzFjxryfj2GaTTfdNB8BAADQ3t/H0fkI6EjQRKeee+65fNQ4d999dzr11FPTXHM1Z6Jd/Ls//OEP08orr5x7GmPy5Mnp5z//eZoyZUruaazXX389feUrX0lrr7127mmsK664Io0cOTLNN998uaex+vTpU513CyywQO5pDU8++WQaPHhwdXzCCSdUf7aSp59+Op133nnp/feb8yso/t241r/5zW/mnsb57W9/m+69997q3GuG+N532223tNpqq+We1jBx4sR0xhlnpBVXXDF961vfyr2t4bXXXks//elP03vvvZd7Gm+hhRZKhx9+eG41zvDhw9Njjz2W5p577tzTOPF7NX637LPPPmnxxRfPvY3zxBNPpF/+8pe51Xhxrffv3z/ttddeuad1HHvssdWfw4YNS6usskp13EqGDh2a/vjHPzbtvc28885bnXvNeE8dv1fffPPN3Gqst99+O22wwQbpiCOOyD09qxn3NWgVgibmGPFGfPfdd08vvfRS7mms5ZdfPl199dVpvfXWyz2N8eKLL6Z11lmnCg6aJQZAhx56aG411imnnNKUwU+beBM+duzYtMgii+Se1jBkyJBpQdP48eNTv379quNWceedd6aNNtqoelPYLJtssklTPo3cb7/9qsFTs8TA48orr0w77bRT7mkNDz74YBowYEDaeOON00033ZR7W8Pzzz9fXaPxwUKzRED3+OOP51bjRKA5bty43Gq8GOg/8MAD1b2+0W6++ea0+eabp3fffTf3NN52222XRowYkVut4Z577qneF4W4V+67777VcSuJoOPkk0/OrcaL+03cM5sRhKy66qrpoYceyq3GO/jgg9Muu+ySW0CzqNEEc4B55pknHzVHs/996udXv/pVU2d31FnMcmhmsE299O3bNx81R7NmSVNfjzzySLr11ltzq37eeuutfNQcd9xxRz4CmslvX+YozZzd8MYbb+QjoKfFTCJBU3M0a7li3TVzVkuIZdJAY/zpT3/KRzTao48+mo+AZhI0MUeJ5XPNEvU/mqWZAVt46qmn8lHjTZgwIR81R7M/eaN5ok4S1EVdP0yJOk2xdK4ZYulSs+ovtpk0aVI+AoDGETQB6dJLL81Hjffss8/mo+bwJry+mj0ApF7qOpOs2ddZfJjQrKU0UUuv2d+/maMANIOgCQCghzU7aGrWLlDN2MUWAGguQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0ARAww0dOjTNM888uUUjzTXXXGnRRRfNLQBKWnLJJdPgwYNzq36a/bt9p512ykdAMwmamKN85CMfyUeNF28MgMZYcMEF81HzzD333PmofhZZZJF8RF3U+XyHRor3svPOO29u1U98mNFMdX7tYU7SZ8yYMe/nY2iq1157LR100EFp4YUXzj2z55FHHklTpkxJq6yySu6ZPe+++2668MIL03rrrZd7GuPFF19Mq666apo4cWLuaby99tqr+t6bYbfddkvXXHNNmm+++XLP7Inz5s0330xLLLFE7pk977//fnXutNrAe8iQIdM+MR0/fnzq169fddwq7rzzzrTBBhukPn365J5ZFz+zuNbj73b1DW38/XXWWSeNHTs29zTOnnvumX796193eeD/3nvvVa9B3759c8/sib/729/+tuU+9X3wwQfTgAED0sYbb5xuuumm3Nsann/++bTWWmulZ599Nvc0Xgx+J02alFuNs9hii6VXXnkltxov7hFnnnlmOvDAA3NP45x44onpmGOO6dJ9LsS1Go/4+129V8Z5d/fdd+ee1nDPPfdU9+cwbNiwtO+++1bHreTggw9Ol112WZp//vlzz6x7+eWX0+TJk9Pyyy+fe2ZfhC3jxo1rSsAc51y8N+uKeC/+xBNPpKWWWqpL44E33ngjbb/99mnvvffOPUCzCJroNU455ZTqTfSoUaNyT2t466230i9+8YsuDxpvueWWatB66qmnpgUWWCD3zrp33nkn7brrrmnZZZfNPY316quvVm8quur0009PV155Zfr7vSz3zL411lgjH7WOVg+awiWXXJKPZs9TTz2Vvv/971ehw3HHHZd7Z99qq602bTDTSM8991x64IEHcmv2xRvouGYiLIpBfFdsscUW+ah1tHLQFOJe/ac//Sm3Zs/o0aPTyJEj084771wFtF11xBFH5KPG2W+//dJdd93VpaAkfj/ed999aaGFFqqu166IgG3EiBFd/jCju2688cZ8NPsiCD/ssMPSlltumY466qjcO3uWW265NHDgwNxqDb0haIpQOT5I7Ir4/X755Zenm2++Ofd0zeqrr56PGmvChAn5aPY988wzadCgQenss89OX/ziF3Pv7Hv00UfzEdAsgiZ6jVYNmror3oTFG/mXXnqpy4POVnbkkUdWr0HMGKiT3hA0dVWENGuuuWbaZJNNuhUwtqoYPPz1r3+tAqv41LcuWj1o6o6TTz65ConOOeecdMABB+Te3u+hhx6qZvyuv/766fbbb8+99fGHP/whbb311mmPPfZIw4cPz729X28ImrojQsVzzz03vfDCC7mnPuKDpBVWWKH6IKo7M7qA5lOjCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBMCHevvtt9Nzzz2Xbr755jRq1Kh0ww03pOuvv746jsejjz6a3njjjfx/A61s8uTJ6a9//eu063vkyJHVn2PGjElPPfVUdT8AAPgwgiYAZvJ///d/6dxzz03bb799+tjHPpaWWWaZtMkmm6TPf/7zaauttkrbbLNNdRyPfv36pQUXXDCtt9566aijjqoGpR2DpzvuuCPtsMMO6W9/+1vuaayJEyem7bbbLvXp06fIY4kllkhbbLFF2nvvvdP5559ffV/vvvtu/tfmfKVfj1l9RFjZLBdffHGnX1NPPg444IA5PoSdMmVKuv/++9MxxxyTBg4cmD7ykY+k1Vdffdr1HfeA+PNzn/tcWmGFFar7QfTF/SHuE+1FSHX33Xen//iP/6jCqt4ggvTPfvaz1c/z9NNPz72t5Uc/+tEM52V3HxtuuOG0e9+TTz6Z3n///fwvAcBUfcaMGeO3A73CKaeckiZNmlQNcutk2LBhab/99ksvvfRSWmyxxXJvfRx55JHVa/D888/nnnoYMmRIGjx4cHU8fvz4KuzprhgsxKDqxz/+cbriiivSq6++WvUvvvjiaffdd0877rhjWnPNNdMCCyxQ9Ye45mJgefnll6ff//730/7OJz7xifTtb3+7OjeXXHLJ9O///u/p0ksvrR4DBgyo/p+ueuCBB6qvI4KvmGUxK2IAPHz48PTKK6/knpTeeeedarZGx/Bjzz33rJ7/wzzxxBPpvvvuq7739t/zl770pep7jgF7DMh6QoQAMYiPWWZLLbVU7p09pV+PNvFa/OEPf0h//vOfc8+MbrrpprTxxhvn1ux58MEHq3Mn/n48z+y67bbb0ujRo3NrqpihM3To0NyaarXVVku77LLLDOf5h4nz8X/+53/Siy++mHum23///atwYlaf64OcfPLJ6YgjjkjnnHNOFV6VEAHTjTfemE444YRp19GnPvWp6ucdoVL//v3TXHNN/zwygtQ47+L/je83fsYRSsV94aMf/Wg107F9kBzn1x577JFbXfPQQw+lVVddNa2//vrp9ttvz72NFWHKt771rep45513rtrx/TZCXEtbb7119TrG69lV8fOKMLG9aHd8zri2IoCeZ555cs+Mxo0bl2699daZPjDYdttt0+GHH54222yzGc6ZrrrnnnvSOuusUx3H7/d99923Oq6L+MAmgtwXXngh99RH3JMj0L7kkkvS8ssvn3uBViRootcQNAma6qR00PTaa6+l0047LZ166qkzBEwxuN1nn32qGTz/yDPPPJPOOOOMdPbZZ097jggGjjvuuPSXv/ylCpkiwFprrbWq/9ZVXQmaOhMzTeI1jNkX7c3OADmWEcXg65e//GW66KKLpoUNe+21Vzr++OPTSiutVLVLKhE0dabE6xEiwIiw6tBDD50pHGhm0NSZ+DrjPGovBs0x+2lWzvk2cf/96U9/ms4666xp536YU4Omxx57rLou//M//7NqDxo0KJ144onVzKW+fftWfR8mfsa33HJL9XVFwNyZ3hA0xX3xoIMOShdccEHVjmDtqquuSltuuWXV7mmlgqbOxDkeoWJ7s3K+xs9+7Nix1f2t48/+O9/5TjV7Kn53dIegSdAkaILWZ+kcQM09/vjj6etf/3o69thjpw2SYzAfdZgOO+ywWR5wL7vsstXMpRiIrb322lVffPIdg5d40xyDxvaD8N5g3nnnrYKzCP7uvPPOKmAKMYD/9Kc/XQ3a6la/KmY0bLrppunCCy9Mn/nMZ3Jv7xYzXGLgffTRR+eeOVOEBBH2xqyVtpApPqiIGS8RaMxKyBTiZxwBXTxXhE0RwPRGEWpfe+21uTV1xl68VnWuUxU/+wj+fvOb36Tvfve7uXeq+JAhgtAIwQGoN0ETQI1FEBSflkc41CZqKcWn3VFzaXbFcrH4tD+Wl7SFDDE461jLpTeK2UsRqLUNvGN20yGHHFIFbc8++2z+v+ojlqD95Cc/qQLINlEbqreKkCZmv0Rw0ya+3zkllIilbxEExAzFtqVPMQMlwtBY3toV8803X3WOz+kBW1fEUuKYORczNduLmVwTJkzIrfpaaKGFqll28fuivVhGfeaZZ7ZUzToAyhM0AdRUDDZjSUL7mjwRDsXyuag31B0xmycCl+4+T6vpbOAdS+qixkvMHKubmBn3ta99Lbemho69WQy+ozZZ23kf3++cMOCOryECpViS0/YziIAgCoDH19wdEbD9y7/8y7TZfL1FhMMjRozIremiNlXUtiJVm0REcNlRfFAR9esAqC9BE0ANRe2Rn/3sZzOETDEL53vf+141E6WEWFpz4IEH5lZ9dDbwjuU2scykbktKIniLwtrtZzX1dlFQe6eddsqt5ouZOZdddllVO6ctZIpr/V//9V+roKCERRZZpAqte9PPOWpCRY2kzkTR/PaF9OtsjTXWmLZUuk2E6t2pnwdA6xM0AdRMDDyjwOp5552Xe6aKHZW+8IUv5Fb3zT333Okb3/hG+uIXv5h76iMG3hGytR94X3311bVcUtJWwLsuIlxrVLHoWRG7I8ZOku1nk335y18u/jOJ2ZBf/epXcyul9957Lx+1nrfeeqvaRS/svffeM9Uai4C+485rdRVh5Sc/+cncmi5en7rVpwNgOkETQM3EwLPjzmIxwyFm4ERAUlLsihYzWuooPuVvP/AOsStZ3ZbdLLroommjjTbKrXqIn/2c8D3HTqwxczF2KWwvljN2d8lcRxGwRajcVhi8lZeKPvzww9VmCBGgRB2rjj/LqNsUO661cphWSmyI0NmGEbGz4euvv55bANSNoAmgRuKT+thtquPAc6uttupS8e9ZscUWW1TPXzcx8N5xxx1za6qYVRKzyWI7/DrZYIMNpgUQdRABayyha7ZY+tW2u1ybuBbXXHPN3Cor7iG94Vq/7bbbqntkzPqKpcRRz6rj+RsznmIrdjoXS4hjhzoA6slvAIAaiU/qr7nmmtyaLrajjy3ae0Isrdh+++1zq16ifsnmm2+eW1PFrkx//OMfc6seVl555apAfB12HwwLLLBAWnfddatgcfLkybm3sSLMHD58eG5NN2jQoCoI6wmLLbZYVZutlcXrFjXVQoRmMfMrZqh1XGoYu8/deeeduUVHURA/rgMA6knQBFATUZvp2muvnWk2U3xSHzNOekqfPn3SZpttVquC0G0WX3zxtPrqq+fWdNddd12t6pd87GMfq4KXZoUuzbD++uunKVOmpDfffDP3NNbYsWM7LWYdoUnUT+sJca1H0NTK1/pDDz1UzWiKukxtS+ZiadjWW29dHbf3u9/9rtpYoc7efvvtNHHixNyaLma3zT///LkFQN0ImgBq4uWXX0433XRTbk0XM01ixklPin/j6aefrlVR6BADrbXWWiu3pouB7BNPPJFbvV/UcTnttNOq7fTrIs75W2+9tSqG3mhRO2j06NEzFAAPEQCtssoqudUz+vfvX81gjNlNrSZet6i9FDWYImT6+Mc/XvV/UFgewf24ceNyq56iFtc999yTW1NFSBdLpgGoL0ETQE088sgjVcDR0QorrFCr+jmN1q9fv3w0XQzM7FpFT4nlX7E9f0cRKMfssp4Us3/OP//8dPDBB+ee1vHcc89V2/LH/TDqMkVA2mbgwIFp2223za2pIpCKQC9mi9ZRBHOxzDBmgbW3++67p5VWWim3AKgjQRNATcQn7zEw6mj55ZdPCy64YG5RWiyf62wp0QMPPJCPoKyYPTh+/Pjcmi4ClIUXXji36CiC+FGjRlUzL2OJYXtRq6mzQucjRoxIzz77bG7VS8yQ7biD6c4771ztahizwACoL0ETQA3EJ+4dP3VuE4PPnqrZQqoG9p0VX44lJ3Wq00TjxMyczq73mGUiVO5c1FqKmksh6jF1tmV/LKeLZWHtRR2szmaP9XZRCP3www+v7mNtttlmm3TyySenJZdcMvcAUFeCJoAaiILEH/Sp+4orrpiP6Akxo6mzgVdsjd6sQtH0bnXZ3a+kxx57LP35z3+uZh9GPabOZuTEvbKz2kM33HBDeuutt3Krd5s0aVI6/fTTq1ApXq82++yzT7rwwgvTJz/5ydwDQJ0JmgBq4IN2BqLnzTXXXJ3OGHv33XerXcmgtKjH1pkobm3L+Zm135Ez6jBFPabOxHW85ZZbzlTT7vrrr08PP/xwbrWu+++/P/3sZz+rZiV1fPzgBz+olg7GUutDDjkkvfjii9Xf2XTTTasC6meffXZaZpllqj4AEDQB1ECEGh13oGrTt2/ffEQjvfDCC1XR5jndyJEjOx14ftgjCgS3qtgN8Kyzzur0+/qgx5AhQ2pbp6c3aL8j5yabbFLVY/ogsW1/x1pNEVBdd911udW6br755mpnyCOOOGKmx4knnljN3Gr/eyQCt1hiGLMzYxZdXYuiAzAzQRNAzcXSLhovwr/YtWlON3z48E4Hnh/2GDt2bP7brSdCg+OPP77T7+uDHhdccEF65ZVX8jPQauJ8jVpLs7It/2KLLVaFUR3FbnWtEBx/mP333z+9/vrrVWD0QY8ImmLJ3He/+900zzzzpP/6r/9KBxxwQLWs8Mtf/nIV2JmpCYCgCaDm1HNpjpg1Mf/88+fWnCuCps4GnB/2iFkRrSqWTsVss86+rw963H333WnAgAH5GWglEfa2zdSJYt+xvPDDRO2mmNHUsRZRBFWtHLDOqtjcYIMNNqhm8UUR9Nhlrs1VV11VLaU7+uijP3AGLQD1IGgCqIF55523053PaB5bzdNTeuq8ilpvl1xySafLB2fl8Ytf/CJNnjw5P9ucIZZK3njjjdX1uMMOO1T3yn+kf//+aeONN86tqSJYiSWj8RrVRb9+/dI555yTdtppp9wz1UknnZQOPPDA9Pzzz+ceAOpG0ARQA1GHybbmzRHLaWKGTEcxsFUfi57wQaFy1JHqzk6HMftn9OjRnS4fnJVHLLOa03Znu+WWW6qlYLFsbvXVV8+9Hy5mI/7TP/1Tbk0XzzVhwoTcqoell146nXDCCWm11VbLPVNddNFFVbhYl934AJiRoAmgBmKnqQ9aEhKf6NNzYnAe9Zg6WmGFFewARo9YaaWV8tGM4lyMpX5dFedrzErquHRw3Lhxae21187/11TRjv72/18Ulo/i0XOK1157rVryFuLP5ZZbrloaNyuPqEfUUQRWMTuqbtZYY430la98JbemO/fcc6cVWQegXgRNADWx6qqr5qMZxZKPVihK3apiNtM999yTW9NF0DQry3RgdsUsk09/+tO5NV3sDtadGU29zQMPPJCuvfba9IlPfCIdeeSR1ZKv2Xnsueee+ZmmizCtboXh55577rTjjjumZZddNvdMFb9bLr/88vTGG2/kHgDqQtAEUBOxtKFjAdsQg8/YaYieEa9vR7FsLgrqQk+IoKmzZWCxjHPSpEm5VW8xwypm2zzzzDNVjaHjjjsuHX744bP1OPjgg2cKV26++eb0t7/9LbfqI+o1dZzVFu677z4bTgDUkKAJoCbiU/vOBgLjx49PL774Ym5RUgxmY7v8jqIeTAzMoCdEkLnuuuvm1nSPPvpop/XC6ijqVY0YMaI63nLLLdN8881XHc+OCO9jB7r2Irj6/e9/X7tZolG3Kn7HdBRBU7wmANSLoAmgJhZddNGZBkUhBgKdzbop6emnn06f//zn08UXX5x76iF22HrkkUdya7oNN9ywVrsARuD23//939WuXDTG5z73uZlm28SA/+GHH86terv//vurukxxTxw0aFDunT0R6G222Wa5Nd11111Xu9p3888/f1pmmWVyazpLswHqSdAEUCPbbLNNNZumvRgI/O///m9u9Yw77rgjjRo1KrfqIwab8b23F7MgonBu1DWpi5dffjldcMEF6d5778099LSBAwembbfdNremi3phdR/4x05oMesodDf03WKLLWa6p0ZR8Lvuuiu36mHKlCnp7bffzi0A6k7QBFAjK664YlWPpKPYlrunCtjGoO6GG27IrXq57bbbZlo6t/POO8/yNuq9Rczqitcizj8aI5Yy7b333jPNarr99ttrXzPnscceS6NHj65emyhi3Z3QN3aq6xg0hd/97nfVrnZ1ESFTZ0uwoy5gzPwCoF4ETQA1EgOq3XffPW288ca5Z6qeLGAbS/Ouvvrq3KqPKLzccalYDEi/+c1vpr59++aeeohZXeq0NF6cb1/72tdya6qYbfOXv/wlt+opioDHzK64Dw4YMCD3dk3UdoqwqqPYzS52tauL2M2wsyXY/fv3r8I4AOpF0ARQMyuttFI66KCDZviUOUKAyy67rJp9VFI8329+85v0+OOP5576uOaaa9JVV12VW1PruXzve9/rdOe/3ixmdcRsJhovQpD9999/hhk3dd9yPmZujhw5sjrebrvtqtp13bXmmmt2WhQ8Aq2oT1YHTz75ZHrwwQdza7qtt946LbHEErkFQF0ImgBqKGoExdbc7f3617+uZjuUFMtTzj333Nyqj1iac8455+TWVEcffXT1utdNDD5jxhzNEcHmySefPMOOYFGY/dZbb82teomZm3E+Rq20z372s7m3e6IIdmdFwWNXu9jdrreLMC0Kqz/00EO5Z6rY5XSHHXZIffr0yT0A1IWgCaCGYunWoYcemvbbb7/cM/UT+NNOOy0999xzuad7ojbRscceW82gqJOYwXPqqafOEK785Cc/qWYz1W3J3LvvvpuuuOKKmQagNFbsQBfnYNssxrjWzzzzzGLX+uuvv1495nRRBD2KgMf3HzNtVllllfxfuieClNhooWM9rAhf6hDoxU6GMSO2owMPPDCtuuqquQVAnQiaAGpq8cUXTyeeeGL6+te/nntSVUvphBNO6HYR21gqd9hhhxWfITWni2K4gwcPTmeffXbVjoH9WWedVb0WsYypbuLnf/HFF+fW1ICTxosgJGqzxc5/bTObSl7rxxxzTEuEiVEEvS34iRlIJa/JmCHVcflciFmdpZckz0ni/BkyZMhM9/rvfOc7VX0ws5kA6knQBFBjSy65ZPr5z3+ejjjiiNyTqpDk+9//fqc7CP0jsYQiCj/vscceMxXC7s3i+x47dmw1mD/vvPOqvlg2EjWa4lP9OgYsEyZMqGZ2ta/Ptfzyy+cjGi0G/LHjYSyRHTRoUNVXt2s9QqaYZbT55psXWzbXJkLlzpbPXX/99dWMn94oZqv++Mc/nhast4ll2SeddFK18yEA9SRoAqi5GCDFzKZYUtK2A1MMHKJQbgySYvnTrIjlKPE822677bRlY/Hc//Zv/5Yuuuiiqt3bxJbeUfA3dpKLwet1111XzRT70Y9+VL12W265Ze0+0Z8yZUo1u2HXXXet5W6Dc7I4FzfaaKMqGDr88MOr67PUtT6ni+LncX2GTTfdNC299NLVcUmbbLJJFTC3F0uIYwe63lQUPK7xuO/FjKUIlNrEvW/o0KFVwBznFgD11WfMmDH12A6DXu+UU05JkyZNSqNGjco99TBs2LCqzk5spb7YYovl3vo48sgjq9fg+eefzz31EEsVYolWGD9+fOrXr1913F1xDZ1//vnpjDPOmDYT5VOf+lTac889qzovsVX1XHNN/4wilqLcddddVUgVj7Z6TLE8Z999903f+MY30oorrljtOhY1TKJAdsyA6I7YMjx2eYpB3d9/h+XeDzd58uQ0fPjwasepNu+88061+1THgXJ8r/H8H2bcuHHVo/1uavE6ffvb30677LJLWmqppXJveauvvno1eI36Ol39d0q/Hm3iNYlt4+Oc6EwMTmNL+a6IouIRhMbfj+eZXfGzimVM7cV27DEwbi+WQMXPcIEFFsg9M4rXIgocN1IU845Zh3H9HHDAAbm3eyL4uPfee6vnvuSSS6q+OIe/+tWvpi222KKqrdP+Wo+gJmbtRc2tCKpiFlSECVHg/gc/+EH1/8RsqTivouB2BC6XXnrptPC6K2I5Xnwd66+/frr99ttz76yJItyx42XbsrU41+Pri/ta7MS38sorV/0hwre4n8xuKNzxOorgOV6bjsvI4pyNMG+eeeapXrN//ud/nqUt/2P2VdSSintm/DtdFV/T/fffn1tTRbvjc7b/Oj9IXOMxMyx+xm0iYIr3IbFcLu733RX3kHXWWac6jt/v8bukTo466qhqE40XXngh99RH3JNXWGGF6p5kBiy0NkETvYagSdBUJz0VNLWJQWWEODEwi2uq/fKnDxIDypjhEMtzYjv19gP1OD8POeSQqoZJM4KmiRMnVv9uzCwoIYK02M1r3XXXrQZEMUCLN8ftB+Y9pUTQVPr1mFXNDJqiVlSEZt0VdY2iJlEj9UTQ1CYCp7i+o5jzlVdeOUt11WKJWFznX/rSl6rBYPuAJmZFxXNEuLHPPvt0q+B2d4KmCEJiVl2EFv9IBE1xr2u/M9+s6Op1FIXZ43fXP1IqaIoZlrExQylx34vXasMNN6yux7gHllwmJ2gSNAmaoPUJmug1BE2Cpjrp6aCpvVgmEZ/Yx2D05ZdfrvrefPPNNP/881fHsQQl3hguvPDCVbundSVo6k1KBE2tqLtBUyvryaCpowiZH3vssWk70rW/1iNciK38P2i2V2ndCZp6g1JBU6sRNAmaBE3Q+tRoAuBDxSydj370o9Ub/6hDFI9YXtF2HEuNGhUyAT0rQqS4pju71mO5WaNCJgCgdQmaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARfcaMGfN+PoZpJk2alI9ax/HHH5/eeOONdNJJJ+Weerj22mvTmWeemS677LK00EIL5d76uOCCC6rX4JJLLsk99fDggw+mwYMHV8eHHHJI9WddTJw4MV144YXp4x//eNp1111zb33E9/7qq6+mffbZJy244IK5t/d76aWX0q9+9au03HLLpd122y331sPtt9+e/v5+LW211VZprbXWyr29X9vPfOmll0577LFH7q2PJ554Il1xxRVp4MCB6Qtf+ELurYfTTjut+nPYsGGpb9++1XFdxM981KhRaejQobmnPuKaP++889Jmm22WPvOZz+TeOVf//v3zEdCRoIlObbrppvkIAACA9uIDAKBzgiYAAAAAilCjCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAAihA0AQAAAFCEoAkAAACAIgRNAAAAABQhaAIAAACgCEETAAAAAEUImgAAAAAoQtAEAAAAQBGCJgAAAACKEDQBAAAAUISgCQAAAIAiBE0AAAAAFCFoAgAAAKAIQRMAAAAARQiaAAAAAChC0AQAAABAEYImAAAAAIoQNAEAAABQhKAJAAAAgCIETQAAAAAUIWgCAAAAoAhBEwAAAABFCJoAAAAAKELQBAAAAEARgiYAAAAACkjp/wHVrqc7xhYS7wAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Notes.png](attachment:b6f37314-e253-479a-b37c-9296e4ca19b8.png)\n",
    "\n",
    "Notes are the smallest building blocks of music. In western music, there are 7 natural notes which are represented with letters as A, B, C, D, E, F, G. These natural notes are the white keys of a piano. Except for 2 cases, the interval between two natural notes is a whole step. Since the smallest interval is half step, there are also other notes between natural notes which are black keys of a piano. For example, we can call the note between A and B as A Sharp (A#) or B flat (Bb). The two exception cases are, there are no notes between B&C and E&F. After placing all the notes in between, all the consecutive intervals are half steps and there are 12 notes in total as:\n",
    "\n",
    "A A# B C C# D D# E F F# G G#\n",
    "\n",
    "One of the most important properties of a note is frequency. By knowing the rules, all the note frequencies in western music can be calculated.\n",
    "1. You can use reference note as **A** with frequency **440** Hz.\n",
    "2. If you **double frequency** of a note, you again obtain the **same note** in one octave higher.\n",
    "3. All the intervals between consecutive notes are **equal** in **logarithmic** scale.\n",
    "\n",
    "Let's make some calculations. Using the first two rules, I know that if 440 Hz is \"A\", 880 Hz is also \"A\". The reverse is also true, 440 is the double of 220, so 220 Hz is \"A\" too. Be careful, 660 Hz is **not** \"A\". What about other notes? The third rule says that intervals are equal on a logarithmic scale. Since there are 12 notes, all I have to do is multiply by 2^(1/12) to go to the next note. For example starting from \"A\", ( 440 \\* 2^(1/12) ) is \"A#\", (440 \\* 2^(1/12) \\* 2^(1/12) ) is \"B\", and goes on. After 12 steps, resulting frequency is ( 440 \\* 2^(12/12) ) = 880 Hz which is again \"A\". Cool, right? Enough calculation for us, let's leave the remaining to Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:51.681028Z",
     "iopub.status.busy": "2023-04-24T19:47:51.680796Z",
     "iopub.status.idle": "2023-04-24T19:47:51.725237Z",
     "shell.execute_reply": "2023-04-24T19:47:51.724264Z",
     "shell.execute_reply.started": "2023-04-24T19:47:51.681000Z"
    }
   },
   "outputs": [],
   "source": [
    "# Our hearing range is commonly 20 Hz to 20 kHz\n",
    "# Starting with 55 Hz which is \"A\" (I divided 440 by 2 three times)\n",
    "curr_freq = 55\n",
    "freq_list = []\n",
    "\n",
    "# I want to calculate 8 octaves of notes. Each octave has 12 notes. Looping for 96 steps:\n",
    "for i in range(96): \n",
    "    freq_list.append(curr_freq)\n",
    "    curr_freq *= np.power(2, 1/12) # Multiplying by 2^(1/12)\n",
    "\n",
    "#reshaping and creating dataframe\n",
    "freq_array = np.reshape(np.round(freq_list,1), (8, 12))\n",
    "cols = [\"A\", \"A#\", \"B\", \"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\"]\n",
    "df_note_freqs = pd.DataFrame(freq_array, columns=cols)\n",
    "print(\"NOTE FREQUENCIES IN WESTERN MUSIC\")\n",
    "df_note_freqs.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can either play the notes in sequence to create a melody or play several notes at the same time to form a chord. In music, a chord is three or more different notes that sounded simultaneously. The most common types of chords are Major chords and Minor chords which both have three notes. To form a Major chord, we first choose a root note, then move 2 whole steps to find the second note, and finally move 1.5 steps to find the third note. For C Major chord, root note is \"C\", second note is \"E\" and third note is \"G\".\n",
    "\n",
    "Forming a Minor chord is also similar, the difference is steps. In Minor chord, we first move 1.5 steps and later move 2 whole steps. Example from the same note \"C\", C Minor chord is formed of \"C\", \"Eb\" and \"G\". (Reminder: Eb and D# have same frequencies)\n",
    "\n",
    "The dataset contains different Major and Minor chord recordings in wav format. Since the project is about distinguishing Major and Minor, the steps between the notes are important for us. We will not be interested in the notes of the chord. Now let's listen to some chord examples. Using the IPython package, audio can be displayed and listened to in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:51.726809Z",
     "iopub.status.busy": "2023-04-24T19:47:51.726556Z",
     "iopub.status.idle": "2023-04-24T19:47:51.765691Z",
     "shell.execute_reply": "2023-04-24T19:47:51.764972Z",
     "shell.execute_reply.started": "2023-04-24T19:47:51.726777Z"
    }
   },
   "outputs": [],
   "source": [
    "path_1 = \"data_small/Major/Major_0.wav\"\n",
    "path_2 = \"data_small/Minor/Minor_169.wav\"\n",
    "path_3 = \"data_small/Major/Major_111.wav\"\n",
    "IPython.display.Audio(path_1, rate = 44100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:51.767471Z",
     "iopub.status.busy": "2023-04-24T19:47:51.767246Z",
     "iopub.status.idle": "2023-04-24T19:47:51.790127Z",
     "shell.execute_reply": "2023-04-24T19:47:51.789295Z",
     "shell.execute_reply.started": "2023-04-24T19:47:51.767443Z"
    }
   },
   "outputs": [],
   "source": [
    "IPython.display.Audio(path_2, rate = 44100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:51.792128Z",
     "iopub.status.busy": "2023-04-24T19:47:51.791643Z",
     "iopub.status.idle": "2023-04-24T19:47:51.815896Z",
     "shell.execute_reply": "2023-04-24T19:47:51.815239Z",
     "shell.execute_reply.started": "2023-04-24T19:47:51.792083Z"
    }
   },
   "outputs": [],
   "source": [
    "IPython.display.Audio(path_3, rate = 44100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2. Time and Frequency Domain Representations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, we have seen that notes have frequencies that describe themselves. A sound wave with 220 Hz frequency is an \"A\" note. Here comes the fun part. In nature, musical sound waves never vibrate at a single frequency. When we play a note with an instrument, harmonics of the note occur at the integer multiples of the base note. Playing \"A\" note with 220 Hz also creates waves at 440 Hz, 660 Hz, 880 Hz, 1100 Hz and goes on. We know that 220 Hz, 440 Hz and 880 Hz are all \"A\" notes. But if you look at the table we created, 660 Hz is the \"E\" note and 1000 Hz is somewhere between \"C\" and \"C#\". That's the reason why we love music. That's the reason for harmony. That's the reason why playing some notes together forms a chord and sounds beautiful. All notes contain other notes within themselves.\n",
    "\n",
    "I would like to create a computer-made note to show the concept of harmonics better. To represent a wave at a single frequency, I can define a sine wave as A\\*sin(2\\*pi\\*f\\*t). A is amplitude, f is frequency and t is time. For a sound wave with harmonics, I will first create a sine wave with fundamental frequency and then add its harmonics using a loop. Another important variable in this cell will be the sampling rate. Sound waves are analog signals and to save on a computer, it has to be converted to a digital signal. The sampling rate determines how many numbers we will save in each second. Using 44100 as a sampling rate is very common in practice.\n",
    "\n",
    "The signal I defined will be in time domain. After creating the signal, I will also apply Fourier Transform to convert it into frequency domain. Scipy fft package can be used for this transform. Fft method gives us both positive and negative frequency terms, I only need positive terms. For detailed information about FFT, [Scipy fft documentation](https://docs.scipy.org/doc/scipy/tutorial/fft.html) can be viewed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:51.817739Z",
     "iopub.status.busy": "2023-04-24T19:47:51.817316Z",
     "iopub.status.idle": "2023-04-24T19:47:52.154151Z",
     "shell.execute_reply": "2023-04-24T19:47:52.153315Z",
     "shell.execute_reply.started": "2023-04-24T19:47:51.817696Z"
    }
   },
   "outputs": [],
   "source": [
    "freq = 220 # note frequency\n",
    "fs = 44100 # sampling rate\n",
    "duration = 1 # duration of a signal [seconds]\n",
    "time = np.linspace(0, duration, fs*duration, endpoint=False) # array for time stamps\n",
    "\n",
    "# Creating signal in time domain\n",
    "np.random.seed(42)\n",
    "signal = np.zeros(len(time))\n",
    "for i in range(1,12):\n",
    "    amp = np.random.randint(0,10) # using random numbers for amplitudes\n",
    "    current_freq = i*freq # current harmonic\n",
    "    signal += amp*np.sin(2 * np.pi * current_freq * time)\n",
    "\n",
    "# Fourier Transform\n",
    "N = len(signal)\n",
    "y_freq = fftfreq(N, 1/fs)[:N//2]  # array for frequency stamps\n",
    "signal_f = fft(signal) # Signal in frequency domain\n",
    "signal_f_onesided = 2.0/N * np.abs(signal_f[0:N//2]) # taking positive terms\n",
    "\n",
    "# Displaying audio\n",
    "IPython.display.display(IPython.display.Audio(data=signal, rate=44100))\n",
    "\n",
    "# Plotting signal in time and frequency domains\n",
    "fig, axes = plt.subplots(1, 2, figsize=(12, 3))\n",
    "axes[0].plot(time[:480], signal[:480])\n",
    "axes[0].set_title(\"Sound Wave in Time Domain (Zoomed)\")\n",
    "axes[0].set(xlabel='Time [sec]')\n",
    "axes[1].plot(y_freq[:3000], signal_f_onesided[:3000])\n",
    "axes[1].set_title(\"Sound Wave in Frequency Domain (Zoomed)\")\n",
    "axes[1].set(xlabel='Frequency [Hz]')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listening to the audio that I created, it's pretty clear it's a computer-generated sound, not a natural one. Still, it is aa \"A\" note, and the frequency plot gives us really valuable information. We can see at what frequencies our signal has values. We can see the harmonic structure of a musical wave. We can find frequencies and determine which note it is.\n",
    "\n",
    "It's time to analyze our real recordings. Wav files are Major and Minor chords that contain at least three notes. So, I expect to see a more complicated frequency plot after the Fourier transform. It will be like the three plots are overlapped. Intervals between harmonics will not be equal. This is great because I am planning to build my classification model on the relationship of harmonics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:52.155717Z",
     "iopub.status.busy": "2023-04-24T19:47:52.155468Z",
     "iopub.status.idle": "2023-04-24T19:47:52.756749Z",
     "shell.execute_reply": "2023-04-24T19:47:52.755868Z",
     "shell.execute_reply.started": "2023-04-24T19:47:52.155687Z"
    }
   },
   "outputs": [],
   "source": [
    "path = \"data_small/Major/Major_0.wav\"\n",
    "fs, signal = wavfile.read(path)\n",
    "N = len(signal)\n",
    "time = np.linspace(0., N/fs, N)\n",
    "\n",
    "# Fourier Transform\n",
    "y_freq = fftfreq(N, 1/fs)[:N//2]  # array for frequency stamps\n",
    "signal_f = fft(signal) # Signal in frequency domain\n",
    "signal_f_onesided = 2.0/N * np.abs(signal_f[0:N//2]) # taking positive terms\n",
    "\n",
    "# Plotting signal in time and frequency domains\n",
    "fig, axes = plt.subplots(2, 2, figsize=(12, 7))\n",
    "axes[0,0].plot(time, signal)\n",
    "axes[0,0].set_title(\"Sound Wave in Time Domain (No Zoom)\")\n",
    "axes[0,0].set(xlabel='Time [sec]')\n",
    "axes[0,1].plot(y_freq, signal_f_onesided)\n",
    "axes[0,1].set_title(\"Sound Wave in Frequency Domain (No Zoom)\")\n",
    "axes[0,1].set(xlabel='Frequency [Hz]')\n",
    "axes[1,0].plot(time[(N//2):(N//2+480)], signal[(N//2):(N//2+480)])\n",
    "axes[1,0].set_title(\"Sound Wave in Time Domain (Zoomed)\")\n",
    "axes[1,0].set(xlabel='Time [sec]')\n",
    "axes[1,1].plot(y_freq[:5000], signal_f_onesided[:5000])\n",
    "axes[1,1].set_title(\"Sound Wave in Frequency Domain (Zoomed)\")\n",
    "axes[1,1].set(xlabel='Frequency [Hz]')\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3. Spectrogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, we have seen the time and frequency plots of a sound wave. Now, I also want to plot the spectrogram of the signal. A spectrogram is a powerful way to visualize a signal over time at various frequencies. It is calculated by splitting the signal into small pieces in time and later applying Fourier transform. As a result, a 2D matrix is obtained and can be plotted. Good news: Scipy has a method for spectrogram, so we don't have to do calculations from the scratch. Documentation of the spectrogram method can be found [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.spectrogram.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:52.758210Z",
     "iopub.status.busy": "2023-04-24T19:47:52.757936Z",
     "iopub.status.idle": "2023-04-24T19:47:53.333378Z",
     "shell.execute_reply": "2023-04-24T19:47:53.332551Z",
     "shell.execute_reply.started": "2023-04-24T19:47:52.758177Z"
    }
   },
   "outputs": [],
   "source": [
    "# applying spectrogram\n",
    "f, t, Sxx = spectrogram(signal, fs, nperseg=10000, nfft = 50000)\n",
    "\n",
    "# Plots\n",
    "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
    "axes[0].pcolormesh(t, f, np.log(Sxx), cmap=\"jet\")\n",
    "axes[0].set_title(\"Spectogram (No Zoom)\")\n",
    "axes[0].set(xlabel='Time [sec]', ylabel='Frequency [Hz]')\n",
    "axes[1].pcolormesh(t, f[:1500], np.log(Sxx)[:1500,:], cmap=\"jet\")\n",
    "axes[1].set_title(\"Spectogram (Zoomed)\")\n",
    "axes[1].set(xlabel='Time [sec]', ylabel='Frequency [Hz]')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4. Detection of Harmonic Frequencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarize what we have done so far, we can read a wav file and save it in an array that is in the time domain. By applying the Fourier transform, we can obtain an array in the frequency domain. Also, Spectrogram is applied to obtain a 2D matrix that has both time and frequency information. The time-domain array is not suitable to use in this project. I will not use the Spectrogram matrix too, because our recordings contain only one chord, so frequency information doesn't change with time. For example, if we had a recording that changes chords every second, we would see in the visualization that harmonics are changing every second.\n",
    "\n",
    "In this project, I will continue with the frequency array. There are peak values in the frequency plot which are harmonics. I believe that if I can find at which frequencies peaks occur, I can use that data to build a model. To do this, I will use find_peaks method from Scipy which returns the indices of peaks. When I plug these indices into the frequency stamp array, I will obtain harmonic frequencies. \n",
    "\n",
    "Update: In some files, I have seen a peak at a really small value like 2 Hz. If there is a peak less than 50 Hz, I will ignore that value, because it is most likely noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:53.335316Z",
     "iopub.status.busy": "2023-04-24T19:47:53.334823Z",
     "iopub.status.idle": "2023-04-24T19:47:53.553388Z",
     "shell.execute_reply": "2023-04-24T19:47:53.552523Z",
     "shell.execute_reply.started": "2023-04-24T19:47:53.335271Z"
    }
   },
   "outputs": [],
   "source": [
    "# h: height threshold. I defined as %5 of max value\n",
    "h = signal_f_onesided.max()*5/100\n",
    "peaks, _ = find_peaks(signal_f_onesided, distance=10, height = h)\n",
    "\n",
    "freq_50_index = np.abs(y_freq - 50).argmin() # finding index for 50 Hz\n",
    "peaks = peaks[peaks>freq_50_index] # filtering peaks less than 50 Hz\n",
    "harmonics = y_freq[peaks]\n",
    "print(\"Harmonics: {}\".format(np.round(harmonics)))\n",
    "\n",
    "# Plot\n",
    "i = peaks.max() + 100\n",
    "plt.plot(y_freq[:i], signal_f_onesided[:i])\n",
    "plt.plot(y_freq[peaks], signal_f_onesided[peaks], \"x\")\n",
    "plt.xlabel('Frequency [Hz]')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:53.556508Z",
     "iopub.status.busy": "2023-04-24T19:47:53.556254Z",
     "iopub.status.idle": "2023-04-24T19:47:53.565359Z",
     "shell.execute_reply": "2023-04-24T19:47:53.564273Z",
     "shell.execute_reply.started": "2023-04-24T19:47:53.556471Z"
    }
   },
   "outputs": [],
   "source": [
    "# I would like to create a method so that I can use in the next section\n",
    "# The method will read sound file, apply Fourier, find peak frequencies and return\n",
    "# Input: path of the sound file\n",
    "# Output: Frequency peaks\n",
    "# print_peaks = true to plot peaks\n",
    "\n",
    "def find_harmonics(path, print_peaks=False):\n",
    "    fs, X = wavfile.read(path)\n",
    "    N = len(X)\n",
    "    X_F = fft(X)\n",
    "    X_F_onesided = 2.0/N * np.abs(X_F[0:N//2])\n",
    "    freqs = fftfreq(N, 1/fs)[:N//2]\n",
    "    freqs_50_index = np.abs(freqs - 50).argmin()\n",
    "    \n",
    "    h = X_F_onesided.max()*5/100\n",
    "    peaks, _ = find_peaks(X_F_onesided, distance=10, height = h)\n",
    "    peaks = peaks[peaks>freqs_50_index]\n",
    "    harmonics = np.round(freqs[peaks],2)\n",
    "    \n",
    "    if print_peaks:\n",
    "        i = peaks.max() + 100\n",
    "        plt.plot(freqs[:i], X_F_onesided[:i])\n",
    "        plt.plot(freqs[peaks], X_F_onesided[peaks], \"x\")\n",
    "        plt.xlabel('Frequency [Hz]')\n",
    "        plt.show()\n",
    "    return harmonics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:53.567293Z",
     "iopub.status.busy": "2023-04-24T19:47:53.566571Z",
     "iopub.status.idle": "2023-04-24T19:47:53.781998Z",
     "shell.execute_reply": "2023-04-24T19:47:53.781085Z",
     "shell.execute_reply.started": "2023-04-24T19:47:53.567231Z"
    }
   },
   "outputs": [],
   "source": [
    "# Another example to check if method is working correctly\n",
    "path = \"data_small/Minor/Minor_169.wav\"\n",
    "\n",
    "harmonics_2 = find_harmonics(path, print_peaks=True)\n",
    "print(\"Harmonics: {}\".format(np.round(harmonics_2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Importing Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, I will create a DataFrame so that I can analyze all the sound data together. There are more than 800 wav files. First, I will loop through all the files and find harmonics. I will save chord type, file name and all harmonics for each file. I will also save minimum & maximum harmonics and the number of harmonics for easier analysis. After the loop, I will convert it to a DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:53.783599Z",
     "iopub.status.busy": "2023-04-24T19:47:53.783316Z",
     "iopub.status.idle": "2023-04-24T19:47:55.420646Z",
     "shell.execute_reply": "2023-04-24T19:47:55.419466Z",
     "shell.execute_reply.started": "2023-04-24T19:47:53.783562Z"
    }
   },
   "outputs": [],
   "source": [
    "import librosa\n",
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:47:55.423308Z",
     "iopub.status.busy": "2023-04-24T19:47:55.422905Z",
     "iopub.status.idle": "2023-04-24T19:49:35.307759Z",
     "shell.execute_reply": "2023-04-24T19:49:35.306802Z",
     "shell.execute_reply.started": "2023-04-24T19:47:55.423265Z"
    }
   },
   "outputs": [],
   "source": [
    "path = \"data\"\n",
    "data = []\n",
    "max_harm_length = 0 # i will keep track of max harmonic length for naming columns\n",
    "\n",
    "for dirname, _, filenames in os.walk(path):\n",
    "    for filename in filenames:\n",
    "        foldername = os.path.basename(dirname)\n",
    "        full_path = os.path.join(dirname, filename)\n",
    "        y, sr = librosa.load(full_path)\n",
    "        centroids =  librosa.feature.spectral_centroid(y = y, sr=sr)\n",
    "        \n",
    "        cenmean = [np.mean(np.nan_to_num(centroids))]\n",
    "        cenmin = [np.min(centroids)]\n",
    "        cenmax = [np.max(centroids)]\n",
    "        \n",
    "        \n",
    "        max_harm_length = max(max_harm_length, len(centroids))\n",
    "        \n",
    "        cur_data = [foldername, filename]\n",
    "        #cur_data.extend([freq_peaks.min(), freq_peaks.max(), len(freq_peaks)])\n",
    "        cur_data.extend(centroids[0,:])\n",
    "        cur_data.extend(cenmean)\n",
    "        cur_data.extend(cenmin)\n",
    "        cur_data.extend(cenmax)\n",
    "        \n",
    "        data.append(cur_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-20T19:51:51.162210Z",
     "iopub.status.busy": "2023-03-20T19:51:51.161544Z",
     "iopub.status.idle": "2023-03-20T19:51:57.987658Z",
     "shell.execute_reply": "2023-03-20T19:51:57.986892Z",
     "shell.execute_reply.started": "2023-03-20T19:51:51.162163Z"
    }
   },
   "source": [
    "path = \"/kaggle/input/musical-instrument-chord-classification/Audio_Files\"\n",
    "data = []\n",
    "max_harm_length = 0 # i will keep track of max harmonic length for naming columns\n",
    "\n",
    "for dirname, _, filenames in os.walk(path):\n",
    "    for filename in filenames:\n",
    "        foldername = os.path.basename(dirname)\n",
    "        full_path = os.path.join(dirname, filename)\n",
    "        freq_peaks = find_harmonics(full_path)\n",
    "        \n",
    "        max_harm_length = max(max_harm_length, len(freq_peaks))\n",
    "        \n",
    "        cur_data = [foldername, filename]\n",
    "        cur_data.extend([freq_peaks.min(), freq_peaks.max(), len(freq_peaks)])\n",
    "        cur_data.extend(freq_peaks)\n",
    "        \n",
    "        data.append(cur_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.309798Z",
     "iopub.status.busy": "2023-04-24T19:49:35.309383Z",
     "iopub.status.idle": "2023-04-24T19:49:35.368852Z",
     "shell.execute_reply": "2023-04-24T19:49:35.368236Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.309765Z"
    }
   },
   "outputs": [],
   "source": [
    "# Column Names for DataFrame:\n",
    "cols = [\"Chord Type\", \"File Name\"]\n",
    "for i in range(100):\n",
    "    cols.append(\"Centroids {}\".format(i+1))\n",
    "    \n",
    "cols.append(\"CenMean\")\n",
    "cols.append(\"CenMin\")\n",
    "cols.append(\"CenMax\")\n",
    "\n",
    "# Creating DataFrame\n",
    "df = pd.DataFrame(data, columns=cols)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.370585Z",
     "iopub.status.busy": "2023-04-24T19:49:35.370212Z",
     "iopub.status.idle": "2023-04-24T19:49:35.378619Z",
     "shell.execute_reply": "2023-04-24T19:49:35.377618Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.370553Z"
    }
   },
   "outputs": [],
   "source": [
    "#Se guarda en nandata las columnas donde hay hay algún dato de tipo NaN\n",
    "nandata = df.columns[df.isna().any()].tolist()\n",
    "\n",
    "print(\"Las columnas con datos faltantes son:\",nandata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.380600Z",
     "iopub.status.busy": "2023-04-24T19:49:35.380362Z",
     "iopub.status.idle": "2023-04-24T19:49:35.409888Z",
     "shell.execute_reply": "2023-04-24T19:49:35.409133Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.380572Z"
    }
   },
   "outputs": [],
   "source": [
    "#Preprocesamiento\n",
    "from sklearn.impute import SimpleImputer #Herramienta para lidiar con datos faltantes\n",
    "#Se corrigen datos faltantes con SimpleImputer\n",
    "imputer = SimpleImputer(missing_values=np.nan, strategy = \"mean\")\n",
    "if nandata != []:\n",
    "  df[nandata] = imputer.fit_transform(df[nandata])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.412207Z",
     "iopub.status.busy": "2023-04-24T19:49:35.411297Z",
     "iopub.status.idle": "2023-04-24T19:49:35.422802Z",
     "shell.execute_reply": "2023-04-24T19:49:35.421819Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.412135Z"
    }
   },
   "outputs": [],
   "source": [
    "#Se guarda en nandata las columnas donde hay hay algún dato de tipo NaN\n",
    "nandata = df.columns[df.isna().any()].tolist()\n",
    "\n",
    "print(\"Las columnas con datos faltantes son:\",nandata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.424399Z",
     "iopub.status.busy": "2023-04-24T19:49:35.424095Z",
     "iopub.status.idle": "2023-04-24T19:49:35.434862Z",
     "shell.execute_reply": "2023-04-24T19:49:35.433920Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.424365Z"
    }
   },
   "outputs": [],
   "source": [
    "# Se obtienen las columnas con variables categóticas\n",
    "cols = df.columns\n",
    "num_cols = df._get_numeric_data().columns\n",
    "catvar = list(set(cols) - set(num_cols))\n",
    "print(\"Las columnas categóricas son:\",catvar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.436310Z",
     "iopub.status.busy": "2023-04-24T19:49:35.436041Z",
     "iopub.status.idle": "2023-04-24T19:49:35.471835Z",
     "shell.execute_reply": "2023-04-24T19:49:35.470456Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.436278Z"
    }
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.474056Z",
     "iopub.status.busy": "2023-04-24T19:49:35.473605Z",
     "iopub.status.idle": "2023-04-24T19:49:35.588019Z",
     "shell.execute_reply": "2023-04-24T19:49:35.586920Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.473999Z"
    }
   },
   "outputs": [],
   "source": [
    "y, sr = librosa.load(\"data_small/Major/Major_0.wav\")\n",
    "cent = librosa.feature.spectral_centroid(y=y, sr=sr)\n",
    "np.mean(cent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.589458Z",
     "iopub.status.busy": "2023-04-24T19:49:35.589224Z",
     "iopub.status.idle": "2023-04-24T19:49:35.595258Z",
     "shell.execute_reply": "2023-04-24T19:49:35.594655Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.589429Z"
    }
   },
   "outputs": [],
   "source": [
    "cent.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.596906Z",
     "iopub.status.busy": "2023-04-24T19:49:35.596598Z",
     "iopub.status.idle": "2023-04-24T19:49:35.623867Z",
     "shell.execute_reply": "2023-04-24T19:49:35.622704Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.596873Z"
    }
   },
   "outputs": [],
   "source": [
    "S, phase = librosa.magphase(librosa.stft(y=y))\n",
    "librosa.feature.spectral_centroid(S=S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.625724Z",
     "iopub.status.busy": "2023-04-24T19:49:35.625388Z",
     "iopub.status.idle": "2023-04-24T19:49:35.651682Z",
     "shell.execute_reply": "2023-04-24T19:49:35.650652Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.625681Z"
    }
   },
   "outputs": [],
   "source": [
    "freqs, times, D = librosa.reassigned_spectrogram(y, fill_nan=True)\n",
    "librosa.feature.spectral_centroid(S=np.abs(D), freq=freqs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:35.653647Z",
     "iopub.status.busy": "2023-04-24T19:49:35.653285Z",
     "iopub.status.idle": "2023-04-24T19:49:36.069415Z",
     "shell.execute_reply": "2023-04-24T19:49:36.068711Z",
     "shell.execute_reply.started": "2023-04-24T19:49:35.653600Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from librosa import display\n",
    "times = librosa.times_like(cent)\n",
    "fig, ax = plt.subplots()\n",
    "librosa.display.specshow(librosa.amplitude_to_db(S, ref=np.max),\n",
    "                         y_axis='log', x_axis='time', ax=ax)\n",
    "ax.plot(times, cent.T, label='Spectral centroid', color='w')\n",
    "ax.legend(loc='upper right')\n",
    "ax.set(title='log Power spectrogram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Data Exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we have a nice DataFrame to make some exploration. The first column, Chord Type, is the value that we will predict. It is a categorical column consisting of 2 categories: Major and Minor. By printing value counts of Chord Type, it seems that most of the chords are Major. We have 502 Major chords and 357 Minor chords. \n",
    "\n",
    "The second column is the file name that the row is created from. We will not need this column for model building, I just keep it in case I want to analyze a specific row deeper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:36.071369Z",
     "iopub.status.busy": "2023-04-24T19:49:36.070728Z",
     "iopub.status.idle": "2023-04-24T19:49:36.084567Z",
     "shell.execute_reply": "2023-04-24T19:49:36.083616Z",
     "shell.execute_reply.started": "2023-04-24T19:49:36.071329Z"
    }
   },
   "outputs": [],
   "source": [
    "df[\"Chord Type\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. Min and Max Harmonics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this part, I have plotted distributions of Min Harmonics and Max Harmonics. By setting hue as Chord Type, I can see if chord type affects distribution. As I expected, the distribution of Min Harmonics for Major and Minor chords is extremely close. This is because the min harmonic determines the note of the chord. For example for 110 Hz, we will have either \"A Major\" or \"A Minor\" chord. We cannot determine what chord it is just by the first note. The difference between Major and Minor chords is in the intervals between harmonics.\n",
    "\n",
    "By looking at the distribution of Max harmonics, Major and Minor chords have again a similar behavior. There is a slight difference that I will ignore for now. I decided not to use \"Min Harmonic\" and \"Max Harmonic\" columns in my model building."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:36.086371Z",
     "iopub.status.busy": "2023-04-24T19:49:36.086050Z",
     "iopub.status.idle": "2023-04-24T19:49:36.964775Z",
     "shell.execute_reply": "2023-04-24T19:49:36.963833Z",
     "shell.execute_reply.started": "2023-04-24T19:49:36.086336Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "sns.kdeplot(ax=axes[0], data=df, x=\"CenMin\", hue=\"Chord Type\", shade=True)\n",
    "sns.kdeplot(ax=axes[1], data=df, x=\"CenMax\", hue=\"Chord Type\", shade=True)\n",
    "sns.scatterplot(ax=axes[2], data=df, x=\"CenMin\", y=\"CenMax\",hue=\"Chord Type\")\n",
    "axes[0].set_title(\"Distribution of Min Centroids\")\n",
    "axes[1].set_title(\"Distribution of Max Centroids\")\n",
    "axes[2].set_title(\"Scatter Plot Min vs. Max Centroids\")\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. Number of Harmonics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the column \"# of Harmonics\", I have information that how many harmonic values are not null in that row. For example if \"# of Harmonics\" is 12, that row will have values from \"Harmonic 1\" to \"Harmonic 12\", but after \"Harmonic 13\" we will see NaN values. This \"# of Harmonics\" column will not be directly related to my classification model but will make it easier to analyze other columns.\n",
    "\n",
    "Using describe method on \"# of harmonics\", I see that\n",
    "* min is 8 --> every row at least 8 harmonics value\n",
    "* max is 38 --> last column will be \"Harmonic 38\"\n",
    "* starting with column \"Harmonic 9\", there will be NaN values\n",
    "* since harmonics are ordered, missing values will increase with each column\n",
    "* the mean value for the number of harmonics is 20\n",
    "\n",
    "Looking at the number of missing values, I know that I will drop most of the columns. Harmonics bigger than 20 are gone. The first 8 harmonics are absolutely important. But I am not sure about the harmonics in between. I have to make more exploration to decide for them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:36.966442Z",
     "iopub.status.busy": "2023-04-24T19:49:36.966141Z",
     "iopub.status.idle": "2023-04-24T19:49:36.977673Z",
     "shell.execute_reply": "2023-04-24T19:49:36.976727Z",
     "shell.execute_reply.started": "2023-04-24T19:49:36.966380Z"
    }
   },
   "outputs": [],
   "source": [
    "df[\"CenMean\"].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Model Building"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:36.982438Z",
     "iopub.status.busy": "2023-04-24T19:49:36.982143Z",
     "iopub.status.idle": "2023-04-24T19:49:37.025135Z",
     "shell.execute_reply": "2023-04-24T19:49:37.024304Z",
     "shell.execute_reply.started": "2023-04-24T19:49:36.982405Z"
    }
   },
   "outputs": [],
   "source": [
    "# importing packages\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "import librosa\n",
    "import numpy as np\n",
    "\n",
    "import sklearn\n",
    "import sklearn.cluster\n",
    "import sklearn.pipeline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1. Preprocessing Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is just one step left before training the classification model. Since the Chord Type column is categorical and consists of strings, I will replace \"Major\" with 1 and \"Minor\" with 0. Finally, select columns that I will use in training and split the data into training and validation sets. I used test size as %40."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:37.026790Z",
     "iopub.status.busy": "2023-04-24T19:49:37.026356Z",
     "iopub.status.idle": "2023-04-24T19:49:37.053920Z",
     "shell.execute_reply": "2023-04-24T19:49:37.052910Z",
     "shell.execute_reply.started": "2023-04-24T19:49:37.026748Z"
    }
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:37.055624Z",
     "iopub.status.busy": "2023-04-24T19:49:37.055362Z",
     "iopub.status.idle": "2023-04-24T19:49:37.074865Z",
     "shell.execute_reply": "2023-04-24T19:49:37.073879Z",
     "shell.execute_reply.started": "2023-04-24T19:49:37.055591Z"
    }
   },
   "outputs": [],
   "source": [
    "dfarray = np.array(df)\n",
    "dfarray = dfarray[:,2:].astype('float64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T19:49:37.076407Z",
     "iopub.status.busy": "2023-04-24T19:49:37.076148Z",
     "iopub.status.idle": "2023-04-24T19:49:37.090662Z",
     "shell.execute_reply": "2023-04-24T19:49:37.089723Z",
     "shell.execute_reply.started": "2023-04-24T19:49:37.076378Z"
    }
   },
   "outputs": [],
   "source": [
    "df[\"Chord Type\"] = df[\"Chord Type\"].replace(\"Major\", 1)\n",
    "df[\"Chord Type\"] = df[\"Chord Type\"].replace(\"Minor\", 0)\n",
    "\n",
    "#columns = [3::]\n",
    "#columns.extend([\"Interval 4_1\", \"Interval 5_1\", \"Interval 6_1\"])\n",
    "train_X, val_X, train_y, val_y = train_test_split(dfarray, df[\"Chord Type\"], test_size=0.2, random_state=0)\n",
    "\n",
    "train_X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2. Model Selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to select a classification model, I will try 6 different models in this section and compare their cross validation score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T20:58:21.049696Z",
     "iopub.status.busy": "2023-04-24T20:58:21.049336Z",
     "iopub.status.idle": "2023-04-24T20:58:21.059399Z",
     "shell.execute_reply": "2023-04-24T20:58:21.058245Z",
     "shell.execute_reply.started": "2023-04-24T20:58:21.049661Z"
    }
   },
   "outputs": [],
   "source": [
    "path = \"data_small/\"\n",
    "def FeatureExtractor(path, n_mels, fmax=20000, fmin=20):\n",
    "\n",
    "    data = []\n",
    "    max_harm_length = 0 # i will keep track of max harmonic length for naming columns\n",
    "    \n",
    "    for dirname, _, filenames in os.walk(path):\n",
    "        for filename in filenames:\n",
    "            foldername = os.path.basename(dirname)\n",
    "            full_path = os.path.join(dirname, filename)\n",
    "            \n",
    "            y, sr = librosa.load(full_path)\n",
    "            mel = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_mels, fmax=fmax, fmin=fmin)\n",
    "            logam = librosa.power_to_db(mel)            \n",
    "            data.append(logam)\n",
    "            \n",
    "            max_harm_length = max(max_harm_length, logam.shape[1])  # fix First step: Track longest frame length\n",
    "            \n",
    "    # fix: Second step: Pad all spectrograms to max_frames\n",
    "    data = [librosa.util.fix_length(mel, size=max_harm_length, axis=1) for mel in data]\n",
    "    \n",
    "    data = np.array(data)        \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-04-24T20:58:21.745520Z",
     "iopub.status.busy": "2023-04-24T20:58:21.745139Z",
     "iopub.status.idle": "2023-04-24T21:00:46.199809Z",
     "shell.execute_reply": "2023-04-24T21:00:46.197963Z",
     "shell.execute_reply.started": "2023-04-24T20:58:21.745487Z"
    }
   },
   "outputs": [],
   "source": [
    "NX = FeatureExtractor(path, n_mels = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.411615Z",
     "iopub.status.idle": "2023-04-24T20:38:49.412493Z",
     "shell.execute_reply": "2023-04-24T20:38:49.412093Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.412053Z"
    }
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(25, 10))\n",
    "librosa.display.specshow(NX[1], \n",
    "                         x_axis=\"time\",\n",
    "                         y_axis=\"mel\", \n",
    "                         sr=sr)\n",
    "plt.colorbar(format=\"%+2.f\")\n",
    "\n",
    "plt.show()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.427002Z",
     "iopub.status.idle": "2023-04-24T20:38:49.432746Z",
     "shell.execute_reply": "2023-04-24T20:38:49.432226Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.432137Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(NX)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.435465Z",
     "iopub.status.idle": "2023-04-24T20:38:49.436620Z",
     "shell.execute_reply": "2023-04-24T20:38:49.436267Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.436224Z"
    }
   },
   "outputs": [],
   "source": [
    "NX[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Itera a través de cada archivo de audio en la carpeta\n",
    "for filename in os.listdir(path):\n",
    "    i=0        \n",
    "    data_min=np.zeros((357,10,80))\n",
    "\n",
    "    if filename.endswith('.wav'): #Solo lea archivos .wav\n",
    "\n",
    "\n",
    "        # Cargar archivo de audio\n",
    "        audio_file = os.path.join(path_audio, filename)\n",
    "        y, sr = librosa.load(audio_file)\n",
    "        \n",
    "        # Calcular espectrograma\n",
    "        spec = librosa.feature.melspectrogram(y=y, sr=sr, n_mels =10)\n",
    "        spec_flat = spec.reshape(-1)\n",
    "        mel = librosa.power_to_db(spec, ref=np.max)\n",
    "        \n",
    "        data_min[i]=mel[:,0:80]\n",
    "        i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.448700Z",
     "iopub.status.idle": "2023-04-24T20:38:49.450385Z",
     "shell.execute_reply": "2023-04-24T20:38:49.449941Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.449892Z"
    }
   },
   "outputs": [],
   "source": [
    "# Now, build a learning object.  We'll use mini-batch k-means with default parameters.\n",
    "C = sklearn.cluster.MiniBatchKMeans()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.452940Z",
     "iopub.status.idle": "2023-04-24T20:38:49.454051Z",
     "shell.execute_reply": "2023-04-24T20:38:49.453701Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.453659Z"
    }
   },
   "outputs": [],
   "source": [
    "# Now, chain them all together into a pipeline\n",
    "ClusterPipe = sklearn.pipeline.Pipeline([('Cluster', C)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.456367Z",
     "iopub.status.idle": "2023-04-24T20:38:49.457469Z",
     "shell.execute_reply": "2023-04-24T20:38:49.457100Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.457059Z"
    }
   },
   "outputs": [],
   "source": [
    "# Let's build a model using just the first 20 seconds of the example track\n",
    "\n",
    "y_train, sr = librosa.load(train_X, duration=20, offset=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T20:38:49.459994Z",
     "iopub.status.idle": "2023-04-24T20:38:49.460508Z",
     "shell.execute_reply": "2023-04-24T20:38:49.460333Z",
     "shell.execute_reply.started": "2023-04-24T20:38:49.460311Z"
    }
   },
   "outputs": [],
   "source": [
    "lr = LogisticRegression(random_state=0,solver='liblinear')\n",
    "knn = KNeighborsClassifier()\n",
    "svc = SVC(random_state=0)\n",
    "gnb = GaussianNB()\n",
    "dtc = DecisionTreeClassifier(random_state=0)\n",
    "rfc = RandomForestClassifier(random_state=0)\n",
    "\n",
    "score_lr = cross_val_score(lr, train_X, train_y, cv=10).mean()\n",
    "score_knn = cross_val_score(knn, train_X, train_y, cv=10).mean()\n",
    "score_svc = cross_val_score(svc, train_X, train_y, cv=10).mean()\n",
    "score_gnb = cross_val_score(gnb, train_X, train_y, cv=10).mean()\n",
    "score_dtc = cross_val_score(dtc, train_X, train_y, cv=10).mean()\n",
    "score_rfc = cross_val_score(rfc, train_X, train_y, cv=10).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T19:52:01.993036Z",
     "iopub.status.idle": "2023-04-24T19:52:01.993385Z",
     "shell.execute_reply": "2023-04-24T19:52:01.993229Z",
     "shell.execute_reply.started": "2023-04-24T19:52:01.993208Z"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Cross Val Score for Logistic Regression: {:.2f}\".format(score_lr))\n",
    "print(\"Cross Val Score for KNeighbors Classifier: {:.2f}\".format(score_knn))\n",
    "print(\"Cross Val Score for SVC: {:.2f}\".format(score_svc))\n",
    "print(\"Cross Val Score for Gaussian NB: {:.2f}\".format(score_gnb))\n",
    "print(\"Cross Val Score for Decision Tree Classifier: {:.2f}\".format(score_dtc))\n",
    "print(\"Cross Val Score for Random Forest Classifier: {:.2f}\".format(score_rfc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3. Model Training and Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, I tried 6 different models and Random Forest Classifier works really well with my dataset. I obtained 0.92 success rate with this model. After Random Forest Classifier, Decision Tree Classifier obtained %90 and KNeighbors Classifier obtained %83 success rate. \n",
    "\n",
    "Now, I will continue with Random Forest Classifier. First, I will train my model with the training dataset and then make a prediction on the validation dataset to see the accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T19:52:01.995535Z",
     "iopub.status.idle": "2023-04-24T19:52:01.996087Z",
     "shell.execute_reply": "2023-04-24T19:52:01.995900Z",
     "shell.execute_reply.started": "2023-04-24T19:52:01.995878Z"
    }
   },
   "outputs": [],
   "source": [
    "# defining my classifier\n",
    "classifier = RandomForestClassifier(random_state=0)\n",
    "\n",
    "classifier.fit(train_X, train_y) # training classifier\n",
    "pred_y = classifier.predict(val_X) # making prediction on validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-04-24T19:52:01.997139Z",
     "iopub.status.idle": "2023-04-24T19:52:01.997695Z",
     "shell.execute_reply": "2023-04-24T19:52:01.997531Z",
     "shell.execute_reply.started": "2023-04-24T19:52:01.997510Z"
    }
   },
   "outputs": [],
   "source": [
    "cm = confusion_matrix(val_y, pred_y)\n",
    "acc = accuracy_score(val_y, pred_y)\n",
    "\n",
    "print(\"Confusion Matrix:\")\n",
    "print(cm)\n",
    "\n",
    "print(\"Accuracy Score: {:.2f}\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-03-20T20:43:13.066373Z",
     "iopub.status.busy": "2023-03-20T20:43:13.065493Z",
     "iopub.status.idle": "2023-03-20T20:43:13.072982Z",
     "shell.execute_reply": "2023-03-20T20:43:13.071743Z",
     "shell.execute_reply.started": "2023-03-20T20:43:13.066294Z"
    }
   },
   "source": [
    "For the validation set, I obtained an even better score, %94 success rate.\n",
    "\n",
    "So, I guess this is the final cell in this notebook. Thank you very much for your interest in this project :)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}