tests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "permanent-tactics",
   "metadata": {},
   "source": [
    "# Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mighty-robert",
   "metadata": {},
   "source": [
    "This Jupyter notebook shows some tests for extracting and experimenting with the constant-Q harmonic coefficients (CQHCs) (more personal).\n",
    "\n",
    "Contents:\n",
    "1. [Preliminary Tests](#1)\n",
    "    1. [Create a note scale and compute its CQT spectrogram](#1A)\n",
    "    2. [Decompose the CQT spectrogram into a spectral component and a pitch component](#1B)\n",
    "    3. [Extract the CQHCs from the spectral component and compare them to the MFCCs](#1C)\n",
    "2. [Test on a Small Dataset](#2)\n",
    "    1. [Create a small dataset from the NSynth dataset](#2A)\n",
    "    2. [Compute the CQHCs and the MFCCs](#2B)\n",
    "    3. [Compare the note similarities](#2C)\n",
    "    4. [Compare the instrument similarities](#2D)\n",
    "    5. [Compare the instrument similarity scores for different versions of CQHCs](#2E)\n",
    "    \n",
    "Author:\n",
    "- Zafar Rafii\n",
    "- zafarrafii@gmail.com\n",
    "- http://zafarrafii.com\n",
    "- https://github.com/zafarrafii\n",
    "- https://www.linkedin.com/in/zafarrafii/\n",
    "- 12/28/21"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "occupational-rebate",
   "metadata": {},
   "source": [
    "## <a id=\"1\"></a>1. Preliminary Tests ##"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "complimentary-remark",
   "metadata": {},
   "source": [
    "### <a id=\"1A\"></a>A. Create a note scale and compute its CQT spectrogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abandoned-parade",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import librosa\n",
    "import librosa.display\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define the parameters for the notes to concatenate\n",
    "folder_path = r'nsynth\\nsynth-train\\audio'\n",
    "instrument_names = ['bass_acoustic_000']\n",
    "note_number = 24\n",
    "note_numbers = np.arange(note_number, note_number+12)\n",
    "velocity_number = 75\n",
    "sampling_frequency = 16000\n",
    "\n",
    "# Loop over the instrument names and note numbers to concatenate the notes\n",
    "audio_signal = np.empty(0)\n",
    "for instrument_name in instrument_names:\n",
    "    for note_number in note_numbers:\n",
    "    \n",
    "        # Get the path to the file\n",
    "        file_name = f'{instrument_name}-{note_number:03d}-{velocity_number:03d}.wav'\n",
    "        file_path = os.path.join(folder_path, file_name)\n",
    "        \n",
    "        # Load the current audio signal and concatenate them\n",
    "        audio_signal1, _ = librosa.load(file_path, sr=sampling_frequency, mono=True)\n",
    "        audio_signal = np.concatenate((audio_signal, audio_signal1))\n",
    "        \n",
    "# Comptute the CQT spectrogram of the signal\n",
    "step_length = int(pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))/2)\n",
    "minimum_frequency = 32.70\n",
    "maximum_frequency = sampling_frequency/2\n",
    "octave_resolution = 12\n",
    "number_frequencies = round(octave_resolution * np.log2(maximum_frequency / minimum_frequency))\n",
    "audio_cqt = librosa.cqt(audio_signal, sr=sampling_frequency, hop_length=step_length, fmin=minimum_frequency, \\\n",
    "                        n_bins=number_frequencies, bins_per_octave=octave_resolution)\n",
    "cqt_spectrogram = np.abs(audio_cqt)\n",
    "\n",
    "# Display the audio signal and the CQT spectrogram\n",
    "plt.figure(figsize=(14, 2))\n",
    "librosa.display.waveplot(audio_signal, sr=sampling_frequency)\n",
    "plt.title('Audio signal')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 4))\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, x_axis='time', y_axis='cqt_note', bins_per_octave=octave_resolution)\n",
    "plt.title('CQT spectrogram')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "liked-kinase",
   "metadata": {},
   "source": [
    "### <a id=\"1B\"></a>B. Decompose the CQT spectrogram into a spectral component and a pitch component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "functional-planning",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Derive the CQT envelope and the CQT pitch\n",
    "ftcqt_spectrogram = np.fft.fft(cqt_spectrogram, 2*number_frequencies-1, axis=0)\n",
    "absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "\n",
    "# Resynthesize the CQT spectrogram by convolving the spectral component and pitch component\n",
    "number_times = np.shape(cqt_spectrogram)[1]\n",
    "cqt_spectrogram2 = np.zeros((number_frequencies, number_times))\n",
    "for i in range(number_times):\n",
    "    cqt_spectrogram2[:, i] = np.convolve(spectral_component[:, i], pitch_component[:, i])[0:number_frequencies]\n",
    "\n",
    "# Display the CQT spectrogram, the spectral component, and pitch component, and the resynthesized CQT spectrogram\n",
    "j = 10\n",
    "plt.figure(figsize=(14, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('CQT spectrogram')\n",
    "plt.subplot(1, 3, 2)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(spectral_component, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, x_axis='time')\n",
    "plt.title('Spectral component')\n",
    "plt.subplot(1, 3, 3)\n",
    "librosa.display.specshow(pitch_component, sr=sampling_frequency, hop_length=step_length, fmin=minimum_frequency, \\\n",
    "                         bins_per_octave=octave_resolution, x_axis='time', y_axis='cqt_note')\n",
    "plt.title('Pitch component')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 2))\n",
    "plt.subplot(1, 3, 1), plt.plot(cqt_spectrogram[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 2), plt.plot(spectral_component[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 3), plt.plot(pitch_component[:, j]), plt.ylim(top=1)\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(14, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('CQT spectrogram')\n",
    "plt.subplot(1, 3, 2)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram2, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('Resynthesized CQT spectrogram')\n",
    "plt.subplot(1, 3, 3)\n",
    "librosa.display.specshow(cqt_spectrogram-cqt_spectrogram2, sr=sampling_frequency, hop_length=step_length, \\\n",
    "                         fmin=minimum_frequency, bins_per_octave=octave_resolution, x_axis='time', y_axis='cqt_note')\n",
    "rms_value = np.round(np.sqrt(np.mean(np.power(cqt_spectrogram-cqt_spectrogram2, 2))), 3)\n",
    "plt.title(f'Differences (RMS={rms_value})')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 2))\n",
    "plt.subplot(1, 3, 1), plt.plot(cqt_spectrogram[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 2), plt.plot(cqt_spectrogram2[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 3), plt.plot(cqt_spectrogram[:, j]-cqt_spectrogram2[:, j]), plt.ylim(top=max(cqt_spectrogram[:, j]))\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Refine the pitch component, and then the spectral component\n",
    "pitch_component2 = np.copy(pitch_component)\n",
    "pitch_component2[pitch_component2 < 0] = 0\n",
    "spectral_component2 = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component2, 2*number_frequencies-1, \\\n",
    "                                                                        axis=0)+1e-7), axis=0)[0:number_frequencies, :])\n",
    "\n",
    "# Resynthesize the CQT spectrogram by convolving the refined spectral component and pitch component\n",
    "cqt_spectrogram2 = np.zeros((number_frequencies, number_times))\n",
    "for i in range(number_times):\n",
    "    cqt_spectrogram2[:, i] = np.convolve(spectral_component2[:, i], pitch_component2[:, i])[0:number_frequencies]\n",
    "\n",
    "# Display everything again with the refined versions\n",
    "plt.figure(figsize=(14, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('CQT spectrogram')\n",
    "plt.subplot(1, 3, 2)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(spectral_component2, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, x_axis='time')\n",
    "plt.title('Refined spectral component')\n",
    "plt.subplot(1, 3, 3)\n",
    "librosa.display.specshow(pitch_component2, sr=sampling_frequency, hop_length=step_length, fmin=minimum_frequency, \\\n",
    "                         bins_per_octave=octave_resolution, x_axis='time', y_axis='cqt_note')\n",
    "plt.title('Refined pitch component')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 2))\n",
    "plt.subplot(1, 3, 1), plt.plot(cqt_spectrogram[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 2), plt.plot(spectral_component2[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 3), plt.plot(pitch_component2[:, j]), plt.ylim(top=1)\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(14, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('CQT spectrogram')\n",
    "plt.subplot(1, 3, 2)\n",
    "librosa.display.specshow(librosa.amplitude_to_db(cqt_spectrogram2, ref=np.max), sr=sampling_frequency, \\\n",
    "                         hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution, \\\n",
    "                         x_axis='time', y_axis='cqt_note')\n",
    "plt.title('Resynthesized CQT spectrogram')\n",
    "plt.subplot(1, 3, 3)\n",
    "librosa.display.specshow(cqt_spectrogram-cqt_spectrogram2, sr=sampling_frequency, hop_length=step_length, \\\n",
    "                         fmin=minimum_frequency, bins_per_octave=octave_resolution, x_axis='time', y_axis='cqt_note')\n",
    "rms_value = np.round(np.sqrt(np.mean(np.power(cqt_spectrogram-cqt_spectrogram2, 2))), 3)\n",
    "plt.title(f'Differences (RMS={rms_value})')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 2))\n",
    "plt.subplot(1, 3, 1), plt.plot(cqt_spectrogram[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 2), plt.plot(cqt_spectrogram2[:, j])\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.subplot(1, 3, 3), plt.plot(cqt_spectrogram[:, j]-cqt_spectrogram2[:, j]), plt.ylim(top=max(cqt_spectrogram[:, j]))\n",
    "plt.title('One time frame'), plt.xlabel('Frequency index'), plt.ylabel('Energy')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# # Resynthesize the signal\n",
    "# audio_signal2 = librosa.icqt(cqt_spectrogram2*audio_cqt/cqt_spectrogram, sr=sampling_frequency, \\\n",
    "#                              hop_length=step_length, fmin=minimum_frequency, bins_per_octave=octave_resolution)\n",
    "# audio_signal2 = np.max(abs(audio_signal))*audio_signal2/np.max(abs(audio_signal2))\n",
    "# audio_signal2 = np.pad(audio_signal2, (0, len(audio_signal)-len(audio_signal2)), 'constant', constant_values=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enabling-craft",
   "metadata": {},
   "source": [
    "### <a id=\"1C\"></a>C. Extract the CQHCs from the spectral component and compare them to the MFCCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "natural-binary",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the CQHCs from the spectral component\n",
    "number_coefficients = 20\n",
    "coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "audio_cqhcs = spectral_component[coefficient_indices, :]\n",
    "\n",
    "# Compute the MFCCs using librosa\n",
    "window_length = pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))\n",
    "step_length = int(window_length/2)\n",
    "audio_mfcc = librosa.feature.mfcc(y=audio_signal, sr=sampling_frequency, n_fft=window_length, hop_length=step_length)\n",
    "\n",
    "# Compute the self-similarity matrices for the CQHCs and the MFCCs\n",
    "normalized_feature = audio_cqhcs/(np.sqrt(np.sum(np.power(audio_cqhcs, 2), axis=0))+1e-16)\n",
    "similarity_matrix1 = np.matmul(normalized_feature.T, normalized_feature)\n",
    "normalized_feature = audio_mfcc/(np.sqrt(np.sum(np.power(audio_mfcc, 2), axis=0))+1e-16)\n",
    "similarity_matrix2 = np.matmul(normalized_feature.T, normalized_feature)\n",
    "\n",
    "# Plot the features and their self-similarity matrices\n",
    "plt.figure(figsize=(14, 3))\n",
    "plt.subplot(1, 2, 1), plt.imshow(audio_cqhcs, aspect='auto', cmap='jet', origin='lower')\n",
    "plt.title('CQHCs'), plt.xlabel('Time'), plt.ylabel('Coefficient')\n",
    "plt.subplot(1, 2, 2), plt.imshow(audio_mfcc, cmap='jet', aspect='auto', origin='lower')\n",
    "plt.title('MFCCs'), plt.xlabel('Time'), plt.ylabel('Coefficient')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "plt.figure(figsize=(14, 7))\n",
    "plt.subplot(1, 2, 1), plt.imshow(similarity_matrix1, cmap='gray', aspect='auto', origin='lower', vmin=0.9, vmax=1)\n",
    "plt.title('CQHCs self-similarity'), plt.xlabel('Time'), plt.ylabel('Time')\n",
    "plt.subplot(1, 2, 2), plt.imshow(similarity_matrix2, cmap='gray', aspect='auto', origin='lower', vmin=0.9, vmax=1)\n",
    "plt.title('MFCCs self-similarity'), plt.xlabel('Time'), plt.ylabel('Time')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "english-actor",
   "metadata": {},
   "source": [
    "## <a id=\"2\"></a>2. Test on a Small Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interpreted-evolution",
   "metadata": {},
   "source": [
    "### <a id=\"2A\"></a>A. Create a small dataset from the NSynth dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "commercial-mambo",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from shutil import copyfile\n",
    "\n",
    "# The NSynth dataset can be downloaded from: https://magenta.tensorflow.org/datasets/nsynth\n",
    "\n",
    "# Define the folders\n",
    "folder_path = r'nsynth\\nsynth-train\\audio'\n",
    "folder_path2 = r'nsynth11'\n",
    "\n",
    "# Define the instrument names, numbers, and MIDIs\n",
    "instrument_list = [{'name':'bass_acoustic', 'number': '000', 'midi': 24}, \\\n",
    "                   {'name':'brass_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'flute_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'guitar_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'keyboard_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'mallet_acoustic', 'number': '000', 'midi': 72}, \\\n",
    "                   {'name':'organ_electronic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'reed_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'string_acoustic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'synth_lead_synthetic', 'number': '000', 'midi': 60}, \\\n",
    "                   {'name':'vocal_acoustic', 'number': '002', 'midi': 60}]\n",
    "\n",
    "# Loop over the list of notes to create the dataset\n",
    "os.mkdir(folder_path2)\n",
    "number_semitones = 12\n",
    "for i in instrument_list:\n",
    "    for j in range(i['midi'], i['midi']+number_semitones):\n",
    "        file_name = f\"{i['name']}_{i['number']}-{j:03d}-075.wav\"\n",
    "        file_path = os.path.join(folder_path, file_name)\n",
    "        file_path2 = os.path.join(folder_path2, file_name)\n",
    "        copyfile(file_path, file_path2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numerous-volume",
   "metadata": {},
   "source": [
    "### <a id=\"2B\"></a>B. Compute the CQHCs and the MFCCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "present-arcade",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/132: bass_acoustic_000-024-075.wav\n",
      "2/132: bass_acoustic_000-025-075.wav\n",
      "3/132: bass_acoustic_000-026-075.wav\n",
      "4/132: bass_acoustic_000-027-075.wav\n",
      "5/132: bass_acoustic_000-028-075.wav\n",
      "6/132: bass_acoustic_000-029-075.wav\n",
      "7/132: bass_acoustic_000-030-075.wav\n",
      "8/132: bass_acoustic_000-031-075.wav\n",
      "9/132: bass_acoustic_000-032-075.wav\n",
      "10/132: bass_acoustic_000-033-075.wav\n",
      "11/132: bass_acoustic_000-034-075.wav\n",
      "12/132: bass_acoustic_000-035-075.wav\n",
      "13/132: brass_acoustic_000-060-075.wav\n",
      "14/132: brass_acoustic_000-061-075.wav\n",
      "15/132: brass_acoustic_000-062-075.wav\n",
      "16/132: brass_acoustic_000-063-075.wav\n",
      "17/132: brass_acoustic_000-064-075.wav\n",
      "18/132: brass_acoustic_000-065-075.wav\n",
      "19/132: brass_acoustic_000-066-075.wav\n",
      "20/132: brass_acoustic_000-067-075.wav\n",
      "21/132: brass_acoustic_000-068-075.wav\n",
      "22/132: brass_acoustic_000-069-075.wav\n",
      "23/132: brass_acoustic_000-070-075.wav\n",
      "24/132: brass_acoustic_000-071-075.wav\n",
      "25/132: flute_acoustic_000-060-075.wav\n",
      "26/132: flute_acoustic_000-061-075.wav\n",
      "27/132: flute_acoustic_000-062-075.wav\n",
      "28/132: flute_acoustic_000-063-075.wav\n",
      "29/132: flute_acoustic_000-064-075.wav\n",
      "30/132: flute_acoustic_000-065-075.wav\n",
      "31/132: flute_acoustic_000-066-075.wav\n",
      "32/132: flute_acoustic_000-067-075.wav\n",
      "33/132: flute_acoustic_000-068-075.wav\n",
      "34/132: flute_acoustic_000-069-075.wav\n",
      "35/132: flute_acoustic_000-070-075.wav\n",
      "36/132: flute_acoustic_000-071-075.wav\n",
      "37/132: guitar_acoustic_000-060-075.wav\n",
      "38/132: guitar_acoustic_000-061-075.wav\n",
      "39/132: guitar_acoustic_000-062-075.wav\n",
      "40/132: guitar_acoustic_000-063-075.wav\n",
      "41/132: guitar_acoustic_000-064-075.wav\n",
      "42/132: guitar_acoustic_000-065-075.wav\n",
      "43/132: guitar_acoustic_000-066-075.wav\n",
      "44/132: guitar_acoustic_000-067-075.wav\n",
      "45/132: guitar_acoustic_000-068-075.wav\n",
      "46/132: guitar_acoustic_000-069-075.wav\n",
      "47/132: guitar_acoustic_000-070-075.wav\n",
      "48/132: guitar_acoustic_000-071-075.wav\n",
      "49/132: keyboard_acoustic_000-060-075.wav\n",
      "50/132: keyboard_acoustic_000-061-075.wav\n",
      "51/132: keyboard_acoustic_000-062-075.wav\n",
      "52/132: keyboard_acoustic_000-063-075.wav\n",
      "53/132: keyboard_acoustic_000-064-075.wav\n",
      "54/132: keyboard_acoustic_000-065-075.wav\n",
      "55/132: keyboard_acoustic_000-066-075.wav\n",
      "56/132: keyboard_acoustic_000-067-075.wav\n",
      "57/132: keyboard_acoustic_000-068-075.wav\n",
      "58/132: keyboard_acoustic_000-069-075.wav\n",
      "59/132: keyboard_acoustic_000-070-075.wav\n",
      "60/132: keyboard_acoustic_000-071-075.wav\n",
      "61/132: mallet_acoustic_000-072-075.wav\n",
      "62/132: mallet_acoustic_000-073-075.wav\n",
      "63/132: mallet_acoustic_000-074-075.wav\n",
      "64/132: mallet_acoustic_000-075-075.wav\n",
      "65/132: mallet_acoustic_000-076-075.wav\n",
      "66/132: mallet_acoustic_000-077-075.wav\n",
      "67/132: mallet_acoustic_000-078-075.wav\n",
      "68/132: mallet_acoustic_000-079-075.wav\n",
      "69/132: mallet_acoustic_000-080-075.wav\n",
      "70/132: mallet_acoustic_000-081-075.wav\n",
      "71/132: mallet_acoustic_000-082-075.wav\n",
      "72/132: mallet_acoustic_000-083-075.wav\n",
      "73/132: organ_electronic_000-060-075.wav\n",
      "74/132: organ_electronic_000-061-075.wav\n",
      "75/132: organ_electronic_000-062-075.wav\n",
      "76/132: organ_electronic_000-063-075.wav\n",
      "77/132: organ_electronic_000-064-075.wav\n",
      "78/132: organ_electronic_000-065-075.wav\n",
      "79/132: organ_electronic_000-066-075.wav\n",
      "80/132: organ_electronic_000-067-075.wav\n",
      "81/132: organ_electronic_000-068-075.wav\n",
      "82/132: organ_electronic_000-069-075.wav\n",
      "83/132: organ_electronic_000-070-075.wav\n",
      "84/132: organ_electronic_000-071-075.wav\n",
      "85/132: reed_acoustic_000-060-075.wav\n",
      "86/132: reed_acoustic_000-061-075.wav\n",
      "87/132: reed_acoustic_000-062-075.wav\n",
      "88/132: reed_acoustic_000-063-075.wav\n",
      "89/132: reed_acoustic_000-064-075.wav\n",
      "90/132: reed_acoustic_000-065-075.wav\n",
      "91/132: reed_acoustic_000-066-075.wav\n",
      "92/132: reed_acoustic_000-067-075.wav\n",
      "93/132: reed_acoustic_000-068-075.wav\n",
      "94/132: reed_acoustic_000-069-075.wav\n",
      "95/132: reed_acoustic_000-070-075.wav\n",
      "96/132: reed_acoustic_000-071-075.wav\n",
      "97/132: string_acoustic_000-060-075.wav\n",
      "98/132: string_acoustic_000-061-075.wav\n",
      "99/132: string_acoustic_000-062-075.wav\n",
      "100/132: string_acoustic_000-063-075.wav\n",
      "101/132: string_acoustic_000-064-075.wav\n",
      "102/132: string_acoustic_000-065-075.wav\n",
      "103/132: string_acoustic_000-066-075.wav\n",
      "104/132: string_acoustic_000-067-075.wav\n",
      "105/132: string_acoustic_000-068-075.wav\n",
      "106/132: string_acoustic_000-069-075.wav\n",
      "107/132: string_acoustic_000-070-075.wav\n",
      "108/132: string_acoustic_000-071-075.wav\n",
      "109/132: synth_lead_synthetic_000-060-075.wav\n",
      "110/132: synth_lead_synthetic_000-061-075.wav\n",
      "111/132: synth_lead_synthetic_000-062-075.wav\n",
      "112/132: synth_lead_synthetic_000-063-075.wav\n",
      "113/132: synth_lead_synthetic_000-064-075.wav\n",
      "114/132: synth_lead_synthetic_000-065-075.wav\n",
      "115/132: synth_lead_synthetic_000-066-075.wav\n",
      "116/132: synth_lead_synthetic_000-067-075.wav\n",
      "117/132: synth_lead_synthetic_000-068-075.wav\n",
      "118/132: synth_lead_synthetic_000-069-075.wav\n",
      "119/132: synth_lead_synthetic_000-070-075.wav\n",
      "120/132: synth_lead_synthetic_000-071-075.wav\n",
      "121/132: vocal_acoustic_002-060-075.wav\n",
      "122/132: vocal_acoustic_002-061-075.wav\n",
      "123/132: vocal_acoustic_002-062-075.wav\n",
      "124/132: vocal_acoustic_002-063-075.wav\n",
      "125/132: vocal_acoustic_002-064-075.wav\n",
      "126/132: vocal_acoustic_002-065-075.wav\n",
      "127/132: vocal_acoustic_002-066-075.wav\n",
      "128/132: vocal_acoustic_002-067-075.wav\n",
      "129/132: vocal_acoustic_002-068-075.wav\n",
      "130/132: vocal_acoustic_002-069-075.wav\n",
      "131/132: vocal_acoustic_002-070-075.wav\n",
      "132/132: vocal_acoustic_002-071-075.wav\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import librosa\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define a function to compute the CQHCs\n",
    "def cqhc(audio_signal, sampling_frequency, number_coefficients=20):\n",
    "    \n",
    "    # Comptute the CQT spectrogram from the signal\n",
    "    step_length = int(pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))/2)\n",
    "    octave_resolution = 12\n",
    "    minimum_frequency = 32.70\n",
    "    maximum_frequency = sampling_frequency/2\n",
    "    number_frequencies = round(octave_resolution * np.log2(maximum_frequency / minimum_frequency))\n",
    "    cqt_spectrogram = np.abs(librosa.cqt(audio_signal, sr=sampling_frequency, hop_length=step_length, \\\n",
    "                                                  fmin=minimum_frequency, n_bins=number_frequencies, \\\n",
    "                                                  bins_per_octave=octave_resolution))\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    ftcqt_spectrogram = np.fft.fft(cqt_spectrogram, 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and the pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "#     # Refine the spectral component\n",
    "#     pitch_component[pitch_component<0] = 0\n",
    "#     spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component, 2*number_frequencies-1, \\\n",
    "#                                                                            axis=0)+1e-16), axis=0)[0:number_frequencies, :])\n",
    "#     spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Define a function to compute the MFCCs\n",
    "def mfcc(audio_signal, sampling_frequency, number_coefficients=20):\n",
    "    \n",
    "    # Compute the MFCCs using librosa's function\n",
    "    window_length = pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))\n",
    "    step_length = int(window_length/2)\n",
    "    audio_mfcc = librosa.feature.mfcc(y=audio_signal, sr=sampling_frequency, n_mfcc=number_coefficients, \n",
    "                                      n_fft=window_length, hop_length=step_length)\n",
    "    \n",
    "    return audio_mfcc\n",
    "\n",
    "\n",
    "# Get the path to the folder and its files\n",
    "folder_path = r'nsynth11'\n",
    "folder_listdir = os.listdir(folder_path)\n",
    "number_files = len(folder_listdir)\n",
    "\n",
    "# Create an empty list for storing dictionaries\n",
    "audio_list = []\n",
    "\n",
    "# Loop over the files\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    k = k+1\n",
    "    \n",
    "    # Display the name of the file\n",
    "    print(f'{k}/{number_files}: {file_name}')\n",
    "    \n",
    "    # Get the path to the audio file and load it\n",
    "    file_path = os.path.join(folder_path, file_name)\n",
    "    audio_signal, sampling_frequency = librosa.load(file_path, sr=None, mono=True)\n",
    "    \n",
    "    # Compute the CQHCs and the MFCCs\n",
    "    audio_cqhc = cqhc(audio_signal, sampling_frequency)\n",
    "    audio_mfcc = mfcc(audio_signal, sampling_frequency)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    audio_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc, 'mfcc': audio_mfcc}\n",
    "    audio_list.append(audio_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "characteristic-pierce",
   "metadata": {},
   "source": [
    "### <a id=\"2C\"></a>C. Compare the note similarities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aerial-documentary",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize the note similarity matrices for the CQHCs and the MFCCs\n",
    "number_files = len(audio_list)\n",
    "cqhc_similarities = np.zeros((number_files, number_files))\n",
    "mfcc_similarities = np.zeros((number_files, number_files))\n",
    "\n",
    "# Loop over the rows of the matrices\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs and MFCCs for the current audio and normalize them\n",
    "    audio_cqhc0 = audio_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    audio_mfcc0 = audio_list[i]['mfcc']\n",
    "    audio_mfcc0 = audio_mfcc0/(np.sqrt(np.sum(np.power(audio_mfcc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    # Loop over the columns of the matrices\n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQT-SECs and MFCCs for the current audio and normalize them\n",
    "        audio_cqhc1 = audio_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        audio_mfcc1 = audio_list[j]['mfcc']\n",
    "        audio_mfcc1 = audio_mfcc1/(np.sqrt(np.sum(np.power(audio_mfcc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the note similarity between the CQTSCs and between the MFCCs\n",
    "        cqhc_similarities[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        mfcc_similarities[i, j] = np.sum(audio_mfcc0*audio_mfcc1, axis=None)\n",
    "        \n",
    "# Display the note similarity matrices for the CQHCs and the MFCCs\n",
    "plt.figure(figsize=(14, 7))\n",
    "plt.subplot(1, 2, 1), plt.imshow(cqhc_similarities, cmap=\"jet\", aspect=\"auto\", vmin=0, vmax=1, origin=\"lower\")\n",
    "plt.title('CQHC note similarities'), plt.xlabel('Note index'), plt.ylabel('Note index')\n",
    "plt.subplot(1, 2, 2), plt.imshow(mfcc_similarities, cmap=\"jet\", aspect=\"auto\", vmin=0, vmax=1, origin=\"lower\")\n",
    "plt.title('MFCC note similarities'), plt.xlabel('Note index'), plt.ylabel('Note index')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reasonable-transportation",
   "metadata": {},
   "source": [
    "### <a id=\"2D\"></a>D. Compare the instrument similarities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "endangered-model",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAHwCAYAAAA1uUU7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAytElEQVR4nO3debxt93w38M9XbtIEGRqJiKFiKoKibtX0lBpqKIkqilLU86iqIVTV9DyiqFZp8dAhRaOiplA11dAhipoigowPIiQRSSQySiLD7/ljr8vOzb1nr3vO3metffN+v17ndc9ee1ifs86997s/e629drXWAgAAAAzrWkMHAAAAABR0AAAAGAUFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAeqiq/1FVJw6dY5lU1b9W1RNXed+/rar/3X1/n6o6dQ05fruqPrHC9X63jIKCDuuoqo6tqvsMnWNZzBqmM+57lUFbVSdX1f3XkOXCqrr5Ctf73QLMUff/9o+raq/Nln+lqlpV7dddPrS73YVTX781dfvHVdWR3fLTu8J4r6nrf76q3ltVP6iq86rqa1X13KraYfNMrbVPt9ZuPaefbdUzab1V1RFV9T9Xc9/W2oNba29b5X2f1lp7+Wruu4XHekdr7dc2Xe7+Dt1y6vq5/G5hrRR0tks9hvH+VfXBbhBfUFX/UVV3m7p+v+4/7g2bPe6hVfWKqcs7VdXBVfWNqrqoG7hv3fSkYXOttdu11o5Y4892cFUdtpbHWE9V9aSq+sxq7rv5MN3G+8510LbWrttaOym5+t+D7vo1/24BuJpvJ3nspgtVdYck197C7V7d/T+96evd3e2fm+R1Sf40yT5Jfi7JXyc5sLv+Fkm+kOSUJHdore2e5FFJNibZdVE/1CybP/9gbWxPlomCznan5zD+bJKvJ7lZkhsm+UCST1bVXbdxdYcnOSDJ45LsnuSOSb6c5H5r/DFWrSb8254TQx1gUG9P8jtTl5+Y5B/73LGqdk/yJ0n+oLX2/tbaRa21y1prH2qt/VF3s5cl+e/W2nNba6cnSWvtxNba41pr527hMa9ymHX3wvzzur3u51XVu6tq5+66varqw1V1blWdU1WfrqprVdXbM3lu8qFuR8Lzp3YMPKWqvpvkP7Z0SPf0nvfuBfv3VtVh3c6Gr3dHA7ywqs6sqlOqanqP8e5V9ZZux8VpVfWKTUcJbHoxvapeU1U/rKpvV9WDu+temeR/JHljl/eNW9guO3c5zu5+3i9V1T7ddT/Z+96t57NV9Vfd7U6qqnt0y0/pcj9x6nGv9oL41HUvqKpvdT/7cVX1G1PXTa/n7CQHT+8wqKr/6m761e5n+q0t/G5vWFXvq6qzuu3xrKnr7lqTHUHnV9UZVfWXW8oIq+FJPNuVnsP44CSfa629uLV2TmvtgtbaG5IcluTPt2Fd90/ygCQHtta+1Fq7vLV2XmvtTa21t2zlPpsP1vdU1T92w+XYqto4dds/7gboBVV1YlXdr6oelORFSX6rGyhf7W57RFW9sqo+m+RHSW5emx0+V1N73qeeCDy5G4g/rKqnVdUvdU8yzt18AFfV71bV8d1tP15VN526rnX3/0Z33zfVxG2T/G2Su3d5z93KdnlSN6Qv6Ibgb08t/8xm63l6t54LqurlVXWLqvrvbki+p6p26m671feqdYP1c13W06vqjZvuN7WeP6iqbyT5xtSyW1bVU5P8dpLndz/Th7bwu73W1BOHs7tce3bXbfVJDABX8/kku1XVbWtSJh+Tybzu4+5Jdk7yzyvc5v6ZvNi+Fo9O8qBMXvT/hSRP6pb/YZJTk+ydyQ6DFyVprbUnJPlukod1e/tfPfVY905y2yQP7Lnuh2XyIsbPJvlKko9n8vz+Rpk8H/q7qdsemuTyJLdMcuckv5Zk+rD1X05yYpK9krw6yVuqqlprL07y6STP6PI+Yws5npjJjoqbJLlekqcluXgrmX85yde62/1Tkncl+aUu1+MzeSHguj1+9m9l8sLB7pm80HJYVe272XpOymTbv3L6jq21X+m+veP0EReb1GRHx4eSfDWTbXm/JAdV1abfy+uTvL61tluSWyR5T4+80IuCzvamzzB+QJL3bmH5e5L8j+pe+e7h/km+2Fo7ZdsiXsUBmQymPZJ8MMkbk6Sqbp3kGUl+qbW2ayaD+uTW2scyOTLg3d1AuePUYz0hyVMzOSTvOz3X/8tJbpXktzI56uDF3c91uySPrqp7d3kOzOSJxSMyeaLx6STv3OyxHprJgP2FTJ6sPLC1dnwmQ/pzXd49Ng9QVddJ8oYkD+5+1nskOXqFzA9Mcpckd0vy/CSHZDLQb5Lk9pk6FHIFVyR5TiZPQu6eyeB9+ma3eXgm22f/6YWttUOSvCM/PZzyYVt4/Gd29793Jkdo/DDJm7rrtuVJDAA/3Yv+gCTHJzltC7d5Xvei57lV9YNu2fWS/KC1dvkKj329JKevMd8bWmvfa62dk0mpu1O3/LIk+ya5abez4NOttTbjsQ7udi70nQufbq19vPsZ35vJjP6z1tplmTy/2K+q9uheCH5IkoO6xz8zyV9l8oLHJt9prf19a+2KJG/rsvd9AfmyTLblLVtrV7TWvtxaO38rt/12a+0fuvW8O5N5+CettUtba59I8uNMyvqKWmvv7bb7lV3B/kaS6SMhv9da+7/dDpRtnbO/lGTv1tqftNZ+3L3F7e/z0+11WZJbVtVerbULW2uf38bHh61S0Nne9BnGe2XLw/j0JDsk2XNq2Q+mBv65mRzKPr2utQ71z7TWPtoNqbdncoh8MimQP5Nk/6rasbV2cmvtWzMe69DW2rHdILqs5/pf3lq7pBuIFyV5Z2vtzNbaaZmU8Dt3t3takle11o7vtu2fJrnT9F70TJ4QnNta+26S/8xPn6D0cWWS21fVLq2101trx65w21e31s7vbnNMkk+01k5qrZ2X5F+nMm9V98Th8922OjmTPQz33uxmr+qOsFhNeX5akhe31k5trV2ayVEbj6zJ4fLb8iQGgMl8fFwme6a3dnj7a1pre3Rfm04qd3aSvWrltyqdnUkRXYvvT33/oySb9v7+RZJvJvlEd5TYC3o81ra+6H/G1PcXZ/Ic6Iqpy+ny3DTJjklOn3pO83dJrj91/5/8HK21H03dt4+3Z7L3/l1V9b2qenVV7dgzc1prmy+bud6q+p2qOnrq57l9Js/xNlnLDpSbJrnhZs8BX5SfvmDxlCQ/n+SE7ki4h65hXXAVCjrbmz7D+AfZ8jDeN0nrHmOTvaYG/h6ZHIo1va55D/Wdq2pDa+2bSQ7KpNidWVXvqqobznis1QyizQfi1gbkTZO8fmpInZOkMjnsa5OtPUFZUWvtokz24D8tkycOH6mq28wh81bV5D16H66q71fV+Zm84LDXZjdb62D/56ntdXwmL7rsk217EgNwjdda+04mJ4t7SJL3b8NdP5fk0kyOaNqaf0vym6sOt4LuLXR/2Fq7eSZHzD23qjado2Zre9Knl1+UqRPidYf4773KOKdksi2mn9fs1lq7Xc/7r7jnvztC4GWttf0zORLuobnquQPmqttB8PeZHG14ve452jGZPDf5Saw1rOKUTPb07zH1tWtr7SFJ0lr7RmvtsZm8wPHnSQ7vjgiENVPQ2d70HcaP2sLyRyf5fLfHs49/S3LXqrrxNiXsqbX2T621e2VS9lp++v74PkM92WywJ7nBGuKckuT3NhtUu7TW/rvHfWcOyO7wvAdk8oLHCZkM3UX6m249t+reP/aiXHWoJyvnnvUznZLJIfvT22vn1tpp6/0kBmA78ZQk9+1e1O2lO7Lq/yR5U1U9vKquXVU7VtWDq2rT+75fmuQeVfUXVXWDJOnON3JYVe2xlsBV9dDusSrJeZm8UHtld/UZSbb60Z2d/5fJC/e/3r2Q+5JMjq7bZm1yArxPJHltVe3WnSvlFpveytbDinmr6ler6g7diwjnZ3K02JVbu/0cXCeTWXxWt/4nZ7IHfVus9DN9MckFNTkf0C5VtUNV3b6qfqlb3+Orau/W2pVJzu3us8ifl2sQBZ3tSs9h/LJMhvErq2rPqtq1qp6Z5Mndffuu69+SfDKTPaV3qaoN3WM9rap+dy0/R1XduqruW1U/k+SSTPYMTw/1/Wr2mdqPTvKY7uffmOSRa4j0t0leWFW36/LtXlVbepFjS85IcuOaOgnbtKrap6oO7F55vjTJhVn8kNs1kycQF3Z7639/G+8/64nV3yZ55aa3AFTV3t37+Id4EgOw9Fpr32qtHbmK+702yXMzKbdnZfIC6jMy+fSWdG8fu3uS/ZIcW1XnJXlfkiOTXLDG2LfK5MX8CzPZgfDXrbX/7K57VZKXdEdaPW8r2c/L5Pwob87kffcXZXLSudX6nSQ7JTkuk3OjHJ7+RwK+PpO3av2wqt6whetv0D3e+ZkcNfapTI4YW4jW2nFJXpvJdj0jyR0y+YSebXFwkrd1v4NHb/b4V2TyAvqdMjl64weZ/B52727yoEz+vlyYybZ5zCrfEgdX11rz5Wu7+8rkLNtHZjLMvp/kI0nuMXX97ZN8OJNBckUmr34+eOr6/TJ5ZXbDZo97aJJXTF3eKZPC/81uXd/J5D/wn9tKrpOT3L/7/uAkh21pnZmcaO2LmTw5OKfLesPudtdL8plMhutR3bIjkvzPzdZ180w+2/XC7ud/w6b1benny2To32fq8mFJXjJ1+QmZfDTd+Zk8wXnr1HUtk/dUX207ddvoI93P8YMtbJN9Mxnk53W/hyOS7N9d96RM3qe/tfV8JsmTpi6/Ismbu+/vk+TUrWz7X8lkD/qFmbzX/k9WWs/myzJ50nV0l/cDW3j8a2XyhPDE7nf4rSR/2l332G75RZk8qXhDNvt75suXL1++fPny5eua+VWtreXtGbD8ukPUP5/kpW0rH48GAACwaA5x5xqvtXZqkgcn2bf6fe4mAADA3NmDDgAAACNgDzoAAACMwEqfFT0ae+1abb/NP6F4ZK787tAJ+vnKbncZOsJMO9/iR0NHmOln88OhI/Ry+ldvNPtGA7vLbl8eOkIv7byhE8x21N7j//d9+xt9begIvVzry5cNHWFFpyY5u7XNPxpwtPa6VrX9dhg6xcrOv3zoBP3sPHSAHhybOT8bluBfeS1BxiS5ZAk+L2WLH3czMkuwGZNMzsQ7didNTp689+bLl6Kg77dXcuRLh06xsh89Y+gE/VznPtv8CSXr7mb/fNTQEWb6zRw+dIReXrHvnw4dYaYjf3U5JvtlHx06wWw7PWn8/77f/6qbDB2hl91qLZ9ktHi/NnSAbbTfDsmRew6dYmWfPHPoBP3cdugAPYz75a2JJXk9JvssQWPbsBRtIjl+CRrb2F/ITJKLrxg6QT/b+pl7Q3jM5NOfrsYh7gAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI7Cwgl5Vb62qM6vqmKlle1bVJ6vqG92fP7uo9QMAa2OWA8D6WuQe9EOTPGizZS9I8u+ttVsl+ffuMgAwTofGLAeAdbOwgt5a+68k52y2+MAkb+u+f1uShy9q/QDA2pjlALC+1vs96Pu01k7vvv9+kn22dsOqempVHVlVR551wfqEAwBm6jXLrzLHr1y/cACwzAY7SVxrrSVpK1x/SGttY2tt4967rmMwAKCXlWb5Vea4U9ICQC/rPTLPqKp9k6T788x1Xj8AsDZmOQAsyHoX9A8meWL3/ROT/Ms6rx8AWBuzHAAWZJEfs/bOJJ9LcuuqOrWqnpLkz5I8oKq+keT+3WUAYITMcgBYXxsW9cCttcdu5ar7LWqdAMD8mOUAsL6ctgUAAABGQEEHAACAEVDQAQAAYAQUdAAAABgBBR0AAABGQEEHAACAEVDQAQAAYAQUdAAAABgBBR0AAABGQEEHAACAEVDQAQAAYAQUdAAAABgBBR0AAABGQEEHAACAEdgwdIA+2inJZQcNnWJl37jwVkNH6OXL2X/oCDP94m2PHzrCTOd/e+gE/Zx5yT5DR5jthKED9LPjo4ZOMNuV966hI8z0p+OPmCR5dLvx0BFWdOXGM4aOsE0uuDw54syhU6xsz6ED9PT+oQNsJ3YcOkBPl106dILZ7rkEGZPk4qED9PCeK4ZOMNsybMckefTQAdbAHnQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARmDD0AH6qP2THT8ydIqV3emF/2/oCL20f6yhI8x2m6EDzLbbo4dO0M/fHXPQ0BFm2v/2Xx46Qi/f3ne/oSPMdPHdrjd0hJledPbQCfq51gtPGTrCyk7bOHSCbXJlkouHDjHD9YcO0NPYt2OS7DJ0gO3I5UMH2I7sOXSAHs4YOkAP+wwdoKdddhg6QQ9XbHmxPegAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIDFLQq+o5VXVsVR1TVe+sqp2HyAEArI5ZDgDzt+4FvapulORZSTa21m6fZIckj1nvHADA6pjlALAYQx3iviHJLlW1Icm1k3xvoBwAwOqY5QAwZ+te0FtrpyV5TZLvJjk9yXmttU9sfruqempVHVlVR551znqnBAC2ps8sn57j5w8REgCW0BCHuP9skgOT3CzJDZNcp6oev/ntWmuHtNY2ttY27r3neqcEALamzyyfnuO7DRESAJbQEIe43z/Jt1trZ7XWLkvy/iT3GCAHALA6ZjkALMAQBf27Se5WVdeuqkpyvyTHD5ADAFgdsxwAFmCI96B/IcnhSY5K8vUuwyHrnQMAWB2zHAAWY8MQK22tvTTJS4dYNwCwdmY5AMzfUB+zBgAAAExR0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdAAAARkBBBwAAgBFQ0AEAAGAENgwdoJfTkvzx0CFWdt77a+gIvdRH2tARZnr5/Z43dISZfivvHjpCLz//G6cMHWGmdtPl+Ldz6OuHTjDbLueePXSEmS7+j+sNHaGXH//NuP9e3u3CoRNsm+tWcs+dhk6xsiMuHTpBP/cfOkAPlw8doIfLhg7Q0z5DB+hhl6ED9PTZoQP08OihA/RwztABejr5iqETrJ496AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI6CgAwAAwAgo6AAAADACCjoAAACMgIIOAAAAI7Bh6AC97JjkhkOHWNlujxo6QT87bzxn6Agz3TonDh1hpp1y6dAR+nnJ0AFm+/ONQyfo54+fPXSC2V69+8lDR5jttkMH6GfHhwydYGX18aETbJuLW/K1kf+3eYehA/R05tABthOXDx2gp4uHDtDD+J9ZTtxz6AA9nDF0gB52GTpAT7e9ztAJerhoy4vtQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGIFBCnpV7VFVh1fVCVV1fFXdfYgcAMDqmOUAMH8bBlrv65N8rLX2yKraKcm1B8oBAKyOWQ4Ac7aqgl5VO7XWfrzK++6e5FeSPClJusdZ1WMBAKtjlgPA+Mw8xL2qjqiq/aYu3zXJl9awzpslOSvJP1TVV6rqzVV1nTU8HgCwArMcAJZDn/egvyrJx6rq6VX1yiR/m+TJa1jnhiS/mORvWmt3TnJRkhdsfqOqempVHVlVR571ozWsDQBY91k+PcfPXcOKAOCaZOYh7q21j1fV05J8MskPkty5tfb9Nazz1CSntta+0F0+PFso6K21Q5IckiQbb1BtDesDgGu0IWb59By/TZnjANBHn0Pc/3eS/5vJe80OTnJEVf36alfYPSE4papu3S26X5LjVvt4AMDKzHIAWA59ThJ3vSR3ba1dnORzVfWxJG9O8pE1rPeZSd7RnfX1pKztMDsAYGVmOQAsgT6HuB9UVbtU1a1baye21r6T5AFrWWlr7egkG9fyGABAP2Y5ACyHPoe4PyzJ0Uk+1l2+U1V9cMG5AIA5McsBYDn0OYv7wUnumuTc5CevmN98YYkAgHk7OGY5AIxen4J+WWvtvM2WXbmIMADAQpjlALAE+pwk7tiqelySHarqVkmeleS/FxsLAJgjsxwAlkCfPejPTHK7JJcmeWeS85MctMBMAMB8meUAsAT6nMX9R0le3H0BAEvGLAeA5bDVgl5VH0rStnZ9a+2AhSQCAObCLAeA5bLSHvTXdH8+IskNkhzWXX5skjMWGQoAmAuzHACWyFYLemvtU0lSVa9trW2cuupDVXXkwpMBAGtilgPAculzkrjrVNVPPiu1qm6W5DqLiwQAzJlZDgBLoM/HrD0nyRFVdVKSSnLTJL+30FQAwDyZ5QCwBPqcxf1j3Wem3qZbdEJr7dLFxgIA5sUsB4Dl0GcPepLcJcl+3e3vWFVprf3jwlIBAPNmlgPAyM0s6FX19iS3SHJ0kiu6xS2JoQ4AS8AsB4Dl0GcP+sYk+7fWtvo5qot2yY13ygmv2Xeo1fdy231PHjpCL+3oGjrCbOcMHWD78YNHjf/3vdeRg/3Xsk1e8IqhE8zWjhn/7/v3bv+6oSP0csh/PnvoCCs7f+Ps21zVoLP8yiQXD7Hi7dARQwfoYZehA/SwDBmT5LShA/TwiKED9LQM/wd9augAPfQ9/Hpot7p86ASr1+cs7sdk8tmpAMByMssBYAn0eRFkryTHVdUXk/zkhDKttQMWlgoAmCezHACWQJ+CfvCiQwAAC3Xw0AEAgNn6fMzaMrwdAgDYCrMcAJbDVgt6VX2mtXavqrogkzO9/uSqJK21ttvC0wEAq2aWA8By2WpBb63dq/tz1/WLAwDMi1kOAMulz1ncAQAAgAVT0AEAAGAEFHQAAAAYgZkFvar+vM8yAGCczHIAWA599qA/YAvLHjzvIADAwpjlALAEVvqYtd9P8vQkN6+qr01dtWuSzy46GACwNmY5ACyXrRb0JP+U5F+TvCrJC6aWX9BaO2ehqQCAeTDLAWCJrPQ56OclOS/JY6tqhyT7dLe/blVdt7X23XXKCACsglkOAMtlpT3oSZKqekaSg5OckeTKbnFL8guLiwUAzItZDgDLYWZBT3JQklu31s5ecBYAYDEOilkOAKPX5yzup2RyeBwAsJzMcgBYAn32oJ+U5Iiq+kiSSzctbK395cJSAQDzZJYDwBLoU9C/233t1H0BAMvFLAeAJTCzoLfWXpYkVXXt1tqPFh8JAJgnsxwAlsPM96BX1d2r6rgkJ3SX71hVf73wZADAXJjlALAc+pwk7nVJHpjk7CRprX01ya8sMBMAMF+vi1kOAKPXp6CntXbKZouuWEAWAGBBzHIAGL8+J4k7parukaRV1Y5Jnp3k+MXGAgDmyCwHgCXQZw/605L8QZIbJTktyZ26ywDAcjDLAWAJ9DmL+w+S/PY6ZAEAFsAsB4DlMLOgV9XNkjwzyX7Tt2+tHbC4WADAvJjlALAc+rwH/QNJ3pLkQ0muXGgaAGARPhCzHABGr09Bv6S19oaFJwEAFsUsB4Al0Kegv76qXprkE0ku3bSwtXbUwlIBAPNklgPAEuhT0O+Q5AlJ7pufHhbXussAwPiZ5QCwBPoU9EcluXlr7ceLDgMALIRZDgBLoM/noB+TZI8F5wAAFscsB4Al0GcP+h5JTqiqL+Wq71vz0SwAsBz2iFkOAKPXp6C/dOEpAIBFMssBYAnMLOittU+tRxAAYDHMcgBYDjMLelVdkMmZXpNkpyQ7JrmotbbbIoMBAPNhlgPAcuizB33XTd9XVSU5MMndFhkKAJgfsxwAlkOfs7j/RJv4QJIHLiYOALBIZjkAjFefQ9wfMXXxWkk2JrlkYYm2YKev/Dg/d93vrOcqt9nzL3zZ0BH6OWzoALN9+QlDJ5jttKED9HTA+4dOMNvJd7n+0BF6+fE//8zQEWZbgtOA/cXGg4aO0Mv1Lzlj6AgresvGbftfaOhZfnmScW/RZFmO9d9l6ADbiQuGDtDTjYYO0MM5Qwfoqc+ZsYfm3/f8nHHp7NuMVZ+/qw+b+v7yJCdncmgcALAczHIAWAIrFvSq2iHJ11prf7VOeQCAOTLLAWB5rPge9NbaFUkeu05ZAIA5M8sBYHn0OcT9s1X1xiTvTnLRpoWttaMWlgoAmCezHACWQJ+Cfqfuzz+ZWtaS3HfuaQCARbhT96dZDgAj1qegP6W1dtL0gqq6+YLyAADzZ5YDwBLo8znoh29h2XvnHQQAWBizHACWwFb3oFfVbZLcLsnum31+6m5Jdl50MABgbcxyAFguKx3ifuskD02yR676+akXJPlfC8wEAMyHWQ4AS2SrBb219i9J/qWq7t5a+9w6ZgIA5sAsB4Dl0uc96L9RVbtV1Y5V9e9VdVZVPX7hyQCAeTHLAWAJ9Cnov9ZaOz+TQ+ROTnLLJH+0yFAAwFyZ5QCwBPoU9B27P389yXtba+ctMA8AMH9mOQAsgT6fg/6hqjohycVJfr+q9k5yyWJjAQBzZJYDwBKYuQe9tfaCJPdIsrG1dlmSi5IcuOhgAMB8mOUAsBz67EFPktsk2a+qpm//j2tZcVXtkOTIJKe11h66lscCAGYyywFg5GYW9Kp6e5JbJDk6yRXd4pY1DvUkz05yfJLd1vg4AMAKzHIAWA599qBvTLJ/a63Na6VVdeNMTlTzyiTPndfjAgBbZJYDwBLocxb3Y5LcYM7rfV2S5ye5cs6PCwBcnVkOAEugzx70vZIcV1VfTHLppoWttQNWs8KqemiSM1trX66q+6xwu6cmeWqS3KRWsyYAoLPus3x6jl9vNSsBgGugPgX94Dmv855JDqiqhyTZOcluVXVYa+3x0zdqrR2S5JAk+cUdam6H5AHANdDBc368mbN8eo7fvMxxAOhjZkFvrX1qnitsrb0wyQuTpHvV/Xmbl3MAYH7McgBYDlst6FV1QSZneL3aVUlaa80ZWwFgxMxyAFguWy3orbVdF73y1toRSY5Y9HoA4JrILAeA5dLnLO4AAADAginoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIzAhqED9HGt6ybXvtfQKVb2oTxs6Ai9/Pl7Dh46wkwfGzpADw8aOsB25Iv55aEj9HJibj10hJle8pnXDh1hpt1uNnSCft6XRw4dYUU/zAeGjrBNrpVkt6FDzLAUT4iSXD50gB4uGzpAD7sMHaCni4cO0MOybMtlsAz/dpbFsvyfviX2oAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAhuGDtDH5beqnPORnxk6xoqO/41fHDpCL//6oaETzPbihw2doIdHDx2gpz2HDjDb75z3tqEj9HLJkePfmC854bVDR5jpqNNuO3SEXkb/f/q3rj10gm3Sklw2dIgZdhw6QE8XDx2gh12GDrAdWYbf97JYhtKzDL/vZfn3vSz/p2+JPegAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIrHtBr6qbVNV/VtVxVXVsVT17vTMAAKtnlgPAYmwYYJ2XJ/nD1tpRVbVrki9X1Sdba8cNkAUA2HZmOQAswLrvQW+tnd5aO6r7/oIkxye50XrnAABWxywHgMUY9D3oVbVfkjsn+cIWrntqVR1ZVUeefVZb92wAwGxbm+XTc/z8QZIBwPIZrKBX1XWTvC/JQa21q83u1tohrbWNrbWN19u71j8gALCilWb59BzfbZh4ALB0BinoVbVjJgP9Ha219w+RAQBYPbMcAOZviLO4V5K3JDm+tfaX671+AGBtzHIAWIwh9qDfM8kTkty3qo7uvh4yQA4AYHXMcgBYgHX/mLXW2meSeFM5ACwpsxwAFmPQs7gDAAAAEwo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjICCDgAAACOgoAMAAMAIKOgAAAAwAgo6AAAAjMCGoQP0seGclj3fecnQMVZ00gdq6Ai93PzhbegIM932n48aOsJMD8uHho7Qy6v3fenQEWZq91+Ofzvnv3foBLPVc8b/7/vo/PzQEXq56JPj/nt5r4uHTrBt9tghOeC6Q6dY2TvOGzpBPw8bOkAPlw0doIfLhw7Q0/WHDrAd+frQAXpYhn/fyzJ+jh86wBrYgw4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACGwYOkAf53w7OexxQ6dY2eP/aegE/Zz92F2GjjDTnr9+ydARZvrRp4ZO0M+TL/yHoSPM9ryhA/Sz2yOGTjBbe3oNHWGmy/YYOkE/O75x6AQru9bLhk6wbU6/InnleUOnWNmLdx86QT8fHPl2TJIdhw7Qw/lDB+hpGXKO/5nlxH1+ZugEs3320qETzLYsv+8HXH/oBD2cueXF9qADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjoKADAADACCjoAAAAMAIKOgAAAIyAgg4AAAAjMEhBr6oHVdWJVfXNqnrBEBkAgNUzywFg/ta9oFfVDknelOTBSfZP8tiq2n+9cwAAq2OWA8BiDLEH/a5JvtlaO6m19uMk70py4AA5AIDVMcsBYAGGKOg3SnLK1OVTu2VXUVVPraojq+rI89ctGgDQw8xZPj3Hf7Su0QBgeY32JHGttUNaaxtbaxt3GzoMALBNpuf4tYcOAwBLYoiCflqSm0xdvnG3DABYDmY5ACzAEAX9S0luVVU3q6qdkjwmyQcHyAEArI5ZDgALsGG9V9hau7yqnpHk40l2SPLW1tqx650DAFgdsxwAFmPdC3qStNY+muSjQ6wbAFg7sxwA5m+0J4kDAACAaxIFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEagWmtDZ5ipqs5K8p05PuReSX4wx8e7JrMt58e2nA/bcX5sy/lYxHa8aWtt7zk/5sIsYI4n/n7Ok205H7bj/NiW82E7zs+6zfKlKOjzVlVHttY2Dp1je2Bbzo9tOR+24/zYlvNhOy6G7To/tuV82I7zY1vOh+04P+u5LR3iDgAAACOgoAMAAMAIXFML+iFDB9iO2JbzY1vOh+04P7blfNiOi2G7zo9tOR+24/zYlvNhO87Pum3La+R70AEAAGBsrql70AEAAGBUFHQAAAAYgWtcQa+qB1XViVX1zap6wdB5llVV3aSq/rOqjquqY6vq2UNnWmZVtUNVfaWqPjx0lmVWVXtU1eFVdUJVHV9Vdx860zKqqud0/66Pqap3VtXOQ2daFlX11qo6s6qOmVq2Z1V9sqq+0f35s0Nm3B6Y5Wtnjs+fWb525vj8mOWrN/Qsv0YV9KraIcmbkjw4yf5JHltV+w+bamldnuQPW2v7J7lbkj+wLdfk2UmOHzrEduD1ST7WWrtNkjvGNt1mVXWjJM9KsrG1dvskOyR5zLCplsqhSR602bIXJPn31tqtkvx7d5lVMsvnxhyfP7N87czxOTDL1+zQDDjLr1EFPcldk3yztXZSa+3HSd6V5MCBMy2l1trprbWjuu8vyOQ/0BsNm2o5VdWNk/x6kjcPnWWZVdXuSX4lyVuSpLX249bauYOGWl4bkuxSVRuSXDvJ9wbOszRaa/+V5JzNFh+Y5G3d929L8vD1zLQdMsvnwByfL7N87czxuTPLV2noWX5NK+g3SnLK1OVTYxitWVXtl+TOSb4wcJRl9bokz09y5cA5lt3NkpyV5B+6QwzfXFXXGTrUsmmtnZbkNUm+m+T0JOe11j4xbKqlt09r7fTu++8n2WfIMNsBs3zOzPG5eF3M8rUyx+fELF+IdZvl17SCzpxV1XWTvC/JQa2184fOs2yq6qFJzmytfXnoLNuBDUl+McnftNbunOSiOJR4m3XvqTowkydKN0xynap6/LCpth9t8tmmPt+U0TDH184snxtzfE7M8sVa9Cy/phX005LcZOryjbtlrEJV7ZjJUH9Ha+39Q+dZUvdMckBVnZzJYZr3rarDho20tE5NcmprbdMeoMMzGfRsm/sn+XZr7azW2mVJ3p/kHgNnWnZnVNW+SdL9eebAeZadWT4n5vjcmOXzYY7Pj1k+f+s2y69pBf1LSW5VVTerqp0yOVnCBwfOtJSqqjJ5j9DxrbW/HDrPsmqtvbC1duPW2n6Z/H38j9aaVzhXobX2/SSnVNWtu0X3S3LcgJGW1XeT3K2qrt39O79fnKRnrT6Y5Ind909M8i8DZtkemOVzYI7Pj1k+H+b4XJnl87dus3zDoh54jFprl1fVM5J8PJOzGb61tXbswLGW1T2TPCHJ16vq6G7Zi1prHx0uEuSZSd7RPWk/KcmTB86zdFprX6iqw5MclclZnr+S5JBhUy2Pqnpnkvsk2auqTk3y0iR/luQ9VfWUJN9J8ujhEi4/s3xuzHHGyByfA7N8bYae5TU5hB4AAAAY0jXtEHcAAAAYJQUdAAAARkBBBwAAgBFQ0AEAAGAEFHQAAAAYAQUdRqCqLlzl/R5eVfvPO89qVdUeVfX0Fa7/7218vPtU1YfXngwAFsss3+rtzXLYBgo6LLeHJ9niUK+qDesbJUmyR5KtDvXW2j3WLwoALIWHxywHOgo6jEj3KvMRVXV4VZ1QVe+oququ+7OqOq6qvlZVr6mqeyQ5IMlfVNXRVXWL7r6vq6ojkzy7qg6tqkdOPf6FU+v5VFX9S1Wd1D32b1fVF6vq61V1i+52e1fV+6rqS93XPbvlB1fVW7v1nVRVz+pW8WdJbtHl+Yst/HzT69/az/mgbtlRSR4xdd/rdOv8YlV9paoO7Ja/vqr+T/f9A6vqv6rK/20ADMIsN8thLYZ4VQ5Y2Z2T3C7J95J8Nsk9q+r4JL+R5DattVZVe7TWzq2qDyb5cGvt8CTp5uJOrbWN3eVDV1jPHZPcNsk5SU5K8ubW2l2r6tlJnpnkoCSvT/JXrbXPVNXPJfl4d58kuU2SX02ya5ITq+pvkrwgye1ba3da5c95ZJK/T3LfJN9M8u6p2784yX+01n63qvZI8sWq+rckL0zypar6dJI3JHlIa+3KHusHgEUxy81yWBUFHcbni621U5Okqo5Osl+Szye5JMlbavI+rpXey/XuFa6b9qXW2under6V5BPd8q9nMqyT5P5J9u+eLCTJblV13e77j7TWLk1yaVWdmWSfnuvdZEs/54VJvt1a+0a3/LAkT+1u/2tJDqiq53WXd07yc62146vqfyX5ryTPaa19axtzAMC8meVmOayKgg7jc+nU91ck2dBau7yq7prkfkkemeQZmbwyvSUXTX1/ebq3snSHiu20lfVcOXX5yvz0/4ZrJblba+2S6RV0Q/5qOVf8qa5uW+9fSX6ztXbiFq67Q5Kzk9xwGzMAwCKY5VtmlsMM3tsBS6B7pXv31tpHkzwnk0PakuSCTA5L25qTk9yl+/6AJDtu46o/kckhcpty3GnG7WflmeWEJPttet9cksdOXffxJM+cen/bnbs/b5rkDzM5zO7BVfXLa1g/ACyEWZ7ELIeZFHRYDrsm+XBVfS3JZ5I8t1v+riR/1J1o5RZbuN/fJ7l3VX01yd1z1Vfk+3hWko3dyWyOS/K0lW7cWjs7yWer6pgtnVhmlu7V/acm+Uh3Ypkzp65+eSZPSr5WVccmeXk34N+S5Hmtte8leUqSN1fVztu6bgBYMLPcLIeZqrU2dAYAAAC4xrMHHQAAAEZAQQcAAIARUNABAABgBBR0AAAAGAEFHQAAAEZAQQcAAIARUNABAABgBP4/lkS2/XeVUmcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize the instrument similarity matrices and the final score vectors\n",
    "number_instruments = 11\n",
    "cqhc_similarities2 = np.zeros((number_instruments, number_instruments))\n",
    "mfcc_similarities2 = np.zeros((number_instruments, number_instruments))\n",
    "cqhc_scores2 = np.zeros(number_instruments)\n",
    "mfcc_scores2 = np.zeros(number_instruments)\n",
    "\n",
    "# Compute the similarity averaged over the instruments\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_similarities2[i, j] = np.mean(cqhc_similarities[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "        mfcc_similarities2[i, j] = np.mean(mfcc_similarities[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Display the instrument similarity matrices\n",
    "plt.figure(figsize=(14, 7))\n",
    "plt.subplot(1, 2, 1), plt.imshow(cqhc_similarities2, cmap=\"jet\", aspect=\"auto\", vmin=0, vmax=1, origin=\"lower\")\n",
    "plt.title('CQHC instrument similarities'), plt.xlabel('Instrument index'), plt.ylabel('Instrument index')\n",
    "plt.subplot(1, 2, 2), plt.imshow(mfcc_similarities2, cmap=\"jet\", aspect=\"auto\", vmin=0, vmax=1, origin=\"lower\")\n",
    "plt.title('MFCC instrument similarities'), plt.xlabel('Instrument index'), plt.ylabel('Instrument index')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Compute the final scores (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_scores2[i] = (cqhc_similarities2[i, i] \\\n",
    "                       + 1-((np.sum(cqhc_similarities2[i, :])-cqhc_similarities2[i, i])/(number_instruments-1)))/2\n",
    "    mfcc_scores2[i] = (mfcc_similarities2[i, i] \\\n",
    "                       + 1-((np.sum(mfcc_similarities2[i, :])-mfcc_similarities2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final scores\n",
    "plt.figure(figsize=(14, 2))\n",
    "plt.plot(cqhc_scores2, label='CQHC')\n",
    "plt.plot(mfcc_scores2, label='MFCC')\n",
    "plt.title('Instrument scores')\n",
    "plt.xlabel('Instrument index')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spread-coast",
   "metadata": {},
   "source": [
    "### <a id=\"2E\"></a>E. Compare the instrument similarity scores for different versions of CQHCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "educated-detector",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import librosa\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Get the path to the folder and the files\n",
    "folder_path = r'nsynth11'\n",
    "folder_listdir = os.listdir(folder_path)\n",
    "number_files = len(folder_listdir)\n",
    "number_instruments = 11\n",
    "\n",
    "# Define a function to compute the CQT spectrogram\n",
    "def cqtspectrogram(audio_signal, sampling_frequency):\n",
    "    \n",
    "    # Comptute the CQT spectrogram from the signal\n",
    "    step_length = int(pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))/2)\n",
    "    octave_resolution = 12\n",
    "    minimum_frequency = 32.70\n",
    "    maximum_frequency = sampling_frequency/2\n",
    "    number_frequencies = round(octave_resolution * np.log2(maximum_frequency / minimum_frequency))\n",
    "    cqt_spectrogram = np.abs(librosa.cqt(audio_signal, sr=sampling_frequency, hop_length=step_length, \\\n",
    "                                                  fmin=minimum_frequency, n_bins=number_frequencies, \\\n",
    "                                                  bins_per_octave=octave_resolution))\n",
    "    \n",
    "    return cqt_spectrogram\n",
    "\n",
    "# Define a function to compute the MFCCs\n",
    "def mfcc(audio_signal, sampling_frequency, n_mfcc=20):\n",
    "    \n",
    "    # Compute the MFCCs using librosa's function\n",
    "    window_length = pow(2, int(np.ceil(np.log2(0.04*sampling_frequency))))\n",
    "    step_length = int(window_length/2)\n",
    "    audio_mfcc = librosa.feature.mfcc(y=audio_signal, sr=sampling_frequency, n_fft=window_length, hop_length=step_length)\n",
    "    \n",
    "    return audio_mfcc\n",
    "\n",
    "# Loop over the files to store the CQT spectrograms and MFCCs\n",
    "audio_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    k = k+1\n",
    "    \n",
    "    # Get the path to the audio file and load it\n",
    "    file_path = os.path.join(folder_path, file_name)\n",
    "    audio_signal, sampling_frequency = librosa.load(file_path, sr=None, mono=True)\n",
    "    \n",
    "    # Compute the CQT spectrogram and the MFCCs\n",
    "    cqt_spectrogram = cqtspectrogram(audio_signal, sampling_frequency)\n",
    "    audio_mfcc = mfcc(audio_signal, sampling_frequency)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    audio_dict = {'name': file_name[0:-4], 'cqt': cqt_spectrogram, 'mfcc': audio_mfcc}\n",
    "    audio_list.append(audio_dict)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(14, 3))\n",
    "\n",
    "# Define a function to compute the CQHCs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(cqt_spectrogram, 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "#     # Refine the spectral component\n",
    "#     pitch_component[pitch_component<0] = 0\n",
    "#     spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(cqt_pitch, 2*number_frequencies-1, \\\n",
    "#                                                                            axis=0)+1e-16), axis=0)\\\n",
    "#                                  [0:number_frequencies, :])\n",
    "#     spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQT-SECs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "\n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (mag)')\n",
    "\n",
    "\n",
    "# Define a function to compute the CQHCs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(cqt_spectrogram, 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "    # Refine the spectral component\n",
    "    pitch_component[pitch_component<0] = 0\n",
    "    spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component, 2*number_frequencies-1, \\\n",
    "                                                                           axis=0)+1e-16), axis=0)\\\n",
    "                                 [0:number_frequencies, :])\n",
    "#     spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "    \n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (mag, ref)')\n",
    "\n",
    "\n",
    "# Define a function to compute the CQHCs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(cqt_spectrogram, 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "    # Refine the spectral component\n",
    "    pitch_component[pitch_component<0] = 0\n",
    "    spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component, 2*number_frequencies-1, \\\n",
    "                                                                           axis=0)+1e-16), axis=0)\\\n",
    "                                 [0:number_frequencies, :])\n",
    "    spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "    \n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (mag, ref, pos)')\n",
    "\n",
    "\n",
    "# Define a function to compute the CQHCs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(np.power(cqt_spectrogram, 2), 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "#     # Refine the spectral component\n",
    "#     pitch_component[pitch_component<0] = 0\n",
    "#     spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(cqt_pitch, 2*number_frequencies-1, \\\n",
    "#                                                                            axis=0)+1e-16), axis=0)\\\n",
    "#                                  [0:number_frequencies, :])\n",
    "#     spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "\n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (pow)')\n",
    "\n",
    "\n",
    "# Define a function to compute the CQT-SECs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(np.power(cqt_spectrogram, 2), 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "    # Refine the spectral component\n",
    "    pitch_component[pitch_component<0] = 0\n",
    "    spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component, 2*number_frequencies-1, \\\n",
    "                                                                           axis=0)+1e-16), axis=0)\\\n",
    "                                 [0:number_frequencies, :])\n",
    "#     spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "\n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (pow, ref)')\n",
    "\n",
    "\n",
    "# Define a function to compute the CQT-SECs from the CQT spectrogram\n",
    "def cqhc(cqt_spectrogram, number_coefficients=20):\n",
    "    \n",
    "    # Compute the FT of the columns in the CQT spectrogram and their magnitude\n",
    "    number_frequencies = np.shape(cqt_spectrogram)[0]\n",
    "    ftcqt_spectrogram = np.fft.fft(np.power(cqt_spectrogram, 2), 2*number_frequencies-1, axis=0)\n",
    "    absftcqt_spectrogram = abs(ftcqt_spectrogram)\n",
    "    \n",
    "    # Derive the spectral component and pitch component\n",
    "    spectral_component = np.real(np.fft.ifft(absftcqt_spectrogram, axis=0)[0:number_frequencies, :])\n",
    "    pitch_component = np.real(np.fft.ifft(ftcqt_spectrogram/(absftcqt_spectrogram+1e-16), axis=0)[0:number_frequencies, :])\n",
    "    \n",
    "    # Refine the spectral component\n",
    "    pitch_component[pitch_component<0] = 0\n",
    "    spectral_component = np.real(np.fft.ifft(ftcqt_spectrogram/(np.fft.fft(pitch_component, 2*number_frequencies-1, \\\n",
    "                                                                           axis=0)+1e-16), axis=0)\\\n",
    "                                 [0:number_frequencies, :])\n",
    "    spectral_component[spectral_component<0] = 0\n",
    "    \n",
    "    # Get the indices of the CQHCs and extract them\n",
    "    octave_resolution = 12\n",
    "    coefficient_indices = np.round(octave_resolution*np.log2(np.arange(1, number_coefficients+1))).astype(int)\n",
    "    audio_cqhc = spectral_component[coefficient_indices, :]\n",
    "\n",
    "    return audio_cqhc\n",
    "\n",
    "    return cqt_sec\n",
    "\n",
    "# Loop over the files to extract the CQHCs\n",
    "cqt_list = []\n",
    "k = 0\n",
    "for file_name in folder_listdir:\n",
    "    \n",
    "    # Get the CQT spectrogram and extract the CQHCs\n",
    "    cqt_spectrogram = audio_list[k]['cqt']\n",
    "    audio_cqhc = cqhc(cqt_spectrogram)\n",
    "    \n",
    "    # Create a dictionary for the current file and append it to the list\n",
    "    cqt_dict = {'name': file_name[0:-4], 'cqhc': audio_cqhc}\n",
    "    cqt_list.append(cqt_dict)\n",
    "    k = k+1\n",
    "\n",
    "# Loop over the files twice to compute the cosine similarity matrix\n",
    "cqhc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the CQHCs current audio and normalize them\n",
    "    audio_cqhc0 = cqt_list[i]['cqhc']\n",
    "    audio_cqhc0 = audio_cqhc0/(np.sqrt(np.sum(np.power(audio_cqhc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the CQHCs for the current audio and normalize them\n",
    "        audio_cqhc1 = cqt_list[j]['cqhc']\n",
    "        audio_cqhc1 = audio_cqhc1/(np.sqrt(np.sum(np.power(audio_cqhc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the CQHCs\n",
    "        cqhc_matrix[i, j] = np.sum(audio_cqhc0*audio_cqhc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "cqhc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        cqhc_matrix2[i, j] = np.mean(cqhc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "cqhc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    cqhc_vector2[i] = (cqhc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(cqhc_matrix2[i, :])-cqhc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "# Display the final score vectors\n",
    "plt.plot(cqhc_vector2, label='CQHCs (pow, ref, pos)')\n",
    "\n",
    "# Loop over the rows and columns of the matrix\n",
    "mfcc_matrix = np.zeros((number_files, number_files))\n",
    "for i in range(number_files):\n",
    "    \n",
    "    # Get the MFCCs for the current audio and normalize them\n",
    "    audio_mfcc0 = audio_list[i]['mfcc']\n",
    "    audio_mfcc0 = audio_mfcc0/(np.sqrt(np.sum(np.power(audio_mfcc0, 2), axis=None))+1e-16)\n",
    "    \n",
    "    for j in range(number_files):\n",
    "        \n",
    "        # Get the MFCCs for the current audio and normalize them\n",
    "        audio_mfcc1 = audio_list[j]['mfcc']\n",
    "        audio_mfcc1 = audio_mfcc1/(np.sqrt(np.sum(np.power(audio_mfcc1, 2), axis=None))+1e-16)\n",
    "        \n",
    "        # Compute the cosine similarity between the MFCCs\n",
    "        mfcc_matrix[i, j] = np.sum(audio_mfcc0*audio_mfcc1, axis=None)\n",
    "        \n",
    "# Compute the similarity averaged over the instrument classes\n",
    "mfcc_matrix2 = np.zeros((number_instruments, number_instruments))\n",
    "for i in range(number_instruments):\n",
    "    for j in range(number_instruments):\n",
    "        mfcc_matrix2[i, j] = np.mean(mfcc_matrix[i*12:(i+1)*12, j*12:(j+1)*12])\n",
    "\n",
    "# Compute the final score vectors (mean between self-similarity and 1 minus the averaged cross-similarities)\n",
    "mfcc_vector2 = np.zeros(number_instruments)\n",
    "for i in range(number_instruments):\n",
    "    mfcc_vector2[i] = (mfcc_matrix2[i, i] \\\n",
    "    + 1-((np.sum(mfcc_matrix2[i, :])-mfcc_matrix2[i, i])/(number_instruments-1)))/2\n",
    "\n",
    "plt.plot(mfcc_vector2, label='MFCCs')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}