Python Team B Assignment 3 Part 1 Portfolio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2d561eef",
   "metadata": {},
   "source": [
    "# Python Assignment 3 – Part 1\n",
    "### MCT4001 – Team B\n",
    "Arvid, Jakob, Joseph, Kristian\n",
    "## Loading libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35935792",
   "metadata": {},
   "outputs": [],
   "source": [
    "%config IPCompleter.greedy=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "989357b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display as ipd\n",
    "import soundfile as sf\n",
    "import librosa\n",
    "import librosa.display\n",
    "import pandas as pd\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9163772e",
   "metadata": {},
   "source": [
    "## Metrics - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba18b830",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start timer\n",
    "start = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d92844c",
   "metadata": {},
   "source": [
    "## Making a Class and Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "591a9446",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Song:\n",
    "    def __init__(self, a, ha, o):\n",
    "        self.audio = a\n",
    "        self.harmonicAudio = ha\n",
    "        self.onsets = o\n",
    "        self.segments = []\n",
    "    \n",
    "    def segmentAudio(self):\n",
    "        sample_start = 0\n",
    "\n",
    "        # slicing based on onset detection and appending the slices together\n",
    "        for i in self.onsets:\n",
    "            if sample_start != i:\n",
    "                segment = np.array(self.audio[sample_start:i])\n",
    "                harmonicSegment = np.array(self.harmonicAudio[sample_start:i])\n",
    "                self.segments.append(self.createSegmentClass(segment, harmonicSegment))\n",
    "\n",
    "                sample_start = i\n",
    "        \n",
    "        #  add the final segment\n",
    "        if sample_start != (self.audio.size - 1):\n",
    "            segment = self.audio[sample_start:(self.audio.size)]\n",
    "            harmonicSegment = np.array(self.harmonicAudio[sample_start:(self.audio.size)])\n",
    "            self.segments.append(self.createSegmentClass(segment, harmonicSegment))\n",
    "    \n",
    "    def createSegmentClass(self,segment, harmonicSegment):\n",
    "        # Calculate the median value of the spectral centroid\n",
    "        spectralCentroid = librosa.feature.spectral_centroid(y=harmonicSegment, n_fft=1024)\n",
    "        spectralCentroidMean = np.average(spectralCentroid)\n",
    "        return Segment(segment, spectralCentroidMean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9aac9cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define segment class\n",
    "class Segment(Song):\n",
    "    def __init__(self, seg, scm):\n",
    "        self.segment = seg\n",
    "        self.spectralCentroidMean = scm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7da4f9e",
   "metadata": {},
   "source": [
    "## Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1d2c313",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load our two audio files\n",
    "\n",
    "sr=44100\n",
    "\n",
    "song1 = './Files/cullum_shortened.wav'\n",
    "song2 = './Files/rihanna_shortened.wav'\n",
    "\n",
    "cullum, sr = librosa.load(song1, sr=sr)\n",
    "rihanna, sr = librosa.load(song2, sr=sr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d39aa0b4",
   "metadata": {},
   "source": [
    "## Analysis / Segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5abb09c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split each audio file into percussive and harmonic arrays using librosa.decompose.hpss \n",
    "cullum_harmonic, cullum_percussive = librosa.effects.hpss(cullum)\n",
    "rihanna_harmonic, rihanna_percussive = librosa.effects.hpss(rihanna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cad312a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run onset detection on the percussive arrays for each audio file\n",
    "onset_cullum = librosa.onset.onset_detect(cullum_percussive, backtrack=True, units='samples')\n",
    "onset_rihanna = librosa.onset.onset_detect(rihanna_percussive, backtrack=True, units='samples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87422c1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print number of segments for each file\n",
    "print(\"Number of segments for Cullum:\\t\" + str(onset_cullum.size + 1))\n",
    "print(\"Number of segments for Rihanna:\\t\" + str(onset_rihanna.size + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1842fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create classes for each song, then segment each song with Segment classes\n",
    "rihannaClass = Song(rihanna, rihanna_harmonic, onset_rihanna)\n",
    "cullumClass = Song(cullum, cullum_harmonic, onset_cullum)\n",
    "\n",
    "rihannaClass.segmentAudio()\n",
    "cullumClass.segmentAudio()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4892dd77",
   "metadata": {},
   "source": [
    "#### Adding Dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2840a587",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to fill pandas dataframes with information\n",
    "\n",
    "def fill_dataframe(df, segments, str):\n",
    "    \n",
    "    scm = []\n",
    "    segments_length = []\n",
    "    sample_start_counter = 0\n",
    "    sample_start = []\n",
    "    sample_end = []\n",
    "    \n",
    "    for i in segments:\n",
    "        \n",
    "        sample_start.append(sample_start_counter)\n",
    "        sample_end.append(sample_start_counter + len(i.segment))\n",
    "        sample_start_counter = sample_start_counter + len(i.segment)\n",
    "        scm.append(i.spectralCentroidMean)\n",
    "        segments_length.append(len(i.segment))\n",
    "        \n",
    "    df['Scm'] = scm\n",
    "    df['id'] = str\n",
    "    df['Seg_length'] = segments_length\n",
    "    df['Segment_start'] = sample_start\n",
    "    df['Segment_end'] = sample_end\n",
    "        \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ffe199d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the dataframes and putting information into them\n",
    "\n",
    "df_rihanna = pd.DataFrame()\n",
    "df_cullum = pd.DataFrame()\n",
    "\n",
    "fill_dataframe(df_rihanna, rihannaClass.segments, 'rihanna')\n",
    "fill_dataframe(df_cullum, cullumClass.segments, 'cullum')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08a4d8fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merging the two dataframes\n",
    "frames = [df_cullum, df_rihanna]\n",
    "\n",
    "result = pd.concat(frames)\n",
    "\n",
    "# Sorting the two dataframes based on Spectral Centroid Mean in ascending order\n",
    "\n",
    "final = result.sort_values(by=['Scm'], ascending=True)\n",
    "\n",
    "\n",
    "print(\"Total number of segments in output file: \" + str(len(final)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53fec2ee",
   "metadata": {},
   "source": [
    "## Output to .csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e50f545",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print to csv file\n",
    "\n",
    "# Adding new segment start and end positions based on final result\n",
    "\n",
    "sample_start_counter = 0\n",
    "sample_start = []\n",
    "sample_end = []\n",
    "    \n",
    "for index, row in final.iterrows():\n",
    "        \n",
    "    sample_start.append(sample_start_counter)\n",
    "    sample_end.append(sample_start_counter + row['Seg_length'])\n",
    "    sample_start_counter = sample_start_counter + row['Seg_length']\n",
    "    \n",
    "# Adding the two new columns\n",
    "    \n",
    "final['New_Segment_start'] = sample_start\n",
    "final['New_Segment_end'] = sample_end\n",
    "\n",
    "# Printing the csv\n",
    "\n",
    "final.to_csv('output.csv')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9c64999",
   "metadata": {},
   "source": [
    "## Sequencing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f5ffe23",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Adding the segments back together in order of Index from dataframe\n",
    "combined_audio = np.array([])\n",
    "output_file_segments = 0\n",
    "for index, row in final.iterrows():\n",
    "    if row['id'] == 'rihanna':\n",
    "        combined_audio = np.append(combined_audio, rihannaClass.segments[index].segment)\n",
    "    elif row['id'] == 'cullum':\n",
    "        combined_audio = np.append(combined_audio, cullumClass.segments[index].segment)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eda7e416",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparing the new audio file size with the two originals\n",
    "\n",
    "print(\"Total number of samples in both input audio files:\\t{:n} samples\".format(rihanna.size+cullum.size))\n",
    "print(\"Total number of samples in the output audio file:\\t{:n} samples\".format(combined_audio.size))\n",
    "\n",
    "print(\"\\nTime of both input audio files: \\t\\t\\t{:.4f} seconds\".format((rihanna.size+cullum.size) / sr))\n",
    "print(\"Time of output audio file: \\t\\t\\t\\t{:.4f} seconds\".format(combined_audio.size / sr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f366b2ac",
   "metadata": {},
   "source": [
    "#### The re-sequenced version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf092f55",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize and play the newly sequenced audio\n",
    "\n",
    "# Choosing style and colors for the plot\n",
    "plt.style.use('seaborn-pastel')\n",
    "plt.style.use('seaborn-white')\n",
    "fig, ax = plt.subplots(figsize=(16, 4), facecolor='#d3fbb5', dpi=150.0)\n",
    "ax.plot(combined_audio, color='#faa39d')\n",
    "ax.set_facecolor('#e6f0fe')\n",
    "\n",
    "# Setting labels\n",
    "ax.set_title(\"Don't Stop The [combined] Music\", fontsize='24', weight='roman', y=1.05, family='monospace')\n",
    "ax.set_xlabel('time (m)', fontsize='x-large', family='monospace')\n",
    "ax.set_ylabel('amplitude', fontsize='x-large', family='monospace')\n",
    "ax.set_xmargin(0.005)\n",
    "\n",
    "# Generating lists for showing x-axis ticks every minute,\n",
    "# by finding the floor value of (length // 60) + 1 for the np.arange().\n",
    "tick_stop = ((len(combined_audio)/sr)//60)+1\n",
    "s_ticks_value = np.arange(sr*60,sr*60*tick_stop,sr*60)\n",
    "s_ticks = np.arange(int(1),int(1*tick_stop),1)\n",
    "\n",
    "# Showing minutes instead of samples\n",
    "ax.set_xticks(s_ticks_value)\n",
    "ax.set_xticklabels(s_ticks)\n",
    "\n",
    "# Displaying the plot\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "sf.write('./Files/output.wav', combined_audio, sr, 'PCM_16')\n",
    "ipd.Audio(combined_audio, rate=sr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc629441",
   "metadata": {},
   "source": [
    "## Vizualization\n",
    "\n",
    "#### How the segments are re-sequenced\n",
    "Here is a visualization of the first 100 segments after re-sequencing.\n",
    "\n",
    "Two reasons as to why we're not visualizing every segment of the song:\n",
    "1. It takes too much cpu and time to plot the whole song this way.\n",
    "2. It looks nicer when 'zoomed' in, as you can see the source more clearly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6387547",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualizing the first 100 segments\n",
    "\n",
    "# Choosing style and colors for the plot\n",
    "fig, ax = plt.subplots(figsize=(24, 6), facecolor='#d3fbb5', dpi=150)\n",
    "\n",
    "# Setting up for iteration\n",
    "combined_viz = np.array([])\n",
    "x_offset = 0\n",
    "counter = 0\n",
    "\n",
    "# Iterating through the first 100 segments to plot by color-code\n",
    "for index, row in final.iterrows():\n",
    "    if counter > 100:\n",
    "        break\n",
    "    if row['id'] == 'rihanna':\n",
    "        combined_viz = np.append(np.zeros(x_offset), rihannaClass.segments[index].segment)\n",
    "        ax.plot(combined_viz, color='#faa39d')\n",
    "        x_offset = len(combined_viz)\n",
    "    elif row['id'] == 'cullum':\n",
    "        combined_viz = np.append(np.zeros(x_offset), cullumClass.segments[index].segment)\n",
    "        ax.plot(combined_viz, color='#fad29d')\n",
    "        x_offset = len(combined_viz)\n",
    "        counter += 1\n",
    "\n",
    "# Setting labels and design\n",
    "ax.set_title(\"Don't Stop The Music [segments]\", fontsize='36', weight='roman', y=1.02, family='monospace')\n",
    "ax.set_xmargin(0)\n",
    "ax.axis('off')\n",
    "\n",
    "# Adding legend and saving to .png before plotting\n",
    "plt.legend(['– Rihanna', '– Cullum'], loc=(0.90, 0.95), fontsize='22', labelcolor=['#f8756c', '#f8bc6c'], handlelength=0)\n",
    "plt.savefig('output.png', pad_inches=1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63116d95",
   "metadata": {},
   "source": [
    "#### The average (Mean) of the Central Spectroid\n",
    "Visualizing the average of the central spectroid pr segment of each artist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b43d0619",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualization the 'Scm' pr artist\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(24, 10), facecolor='#d3fbb5', dpi=150)\n",
    "\n",
    "# Setting labels and design\n",
    "ax.set_title(\"Mean Central Spectroid pr Segment\", fontsize='36', weight='roman', y=1.03, family='monospace')\n",
    "ax.plot(df_rihanna['Scm'], color='#faa39d', marker='p', mec='k', mew=0.4, mfc='#f8756c', ms=8, label='Rihanna')\n",
    "ax.plot(df_cullum['Scm'], color='#fad29d', marker='^', mec='k', mew=0.4, mfc='#f6b154', ms=8, label='Cullum')\n",
    "ax.set_xlabel('Segment (#)', fontsize='22', family='monospace')\n",
    "ax.set_ylabel('Frequency (Hz)', fontsize='22', family='monospace')\n",
    "ax.set_xmargin(0.005)\n",
    "ax.set_facecolor('#e6f0fe')\n",
    "\n",
    "# Changing y axis to logarithmic representation of frequency\n",
    "ax.set_yscale('log')\n",
    "y_ticks = [250, 500, 1000, 2000, 4000]\n",
    "ax.set_yticks(y_ticks)\n",
    "ax.set_yticklabels(y_ticks)\n",
    "\n",
    "# Adding legend and saving to .png before plotting\n",
    "ax.legend(fontsize='24', markerscale=1.8)\n",
    "plt.savefig('output2.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d2d68b5",
   "metadata": {},
   "source": [
    "## Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45326e18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making the Spectral Centroid Mean ('Scm' column) the source for statistics\n",
    "r_stat = df_rihanna['Scm']\n",
    "c_stat = df_cullum['Scm']\n",
    "\n",
    "# Mean of each artist\n",
    "r_mu = r_stat.mean()\n",
    "c_mu = c_stat.mean()\n",
    "\n",
    "# Standard deviation of each artist\n",
    "r_sig = r_stat.std()\n",
    "c_sig = c_stat.std()\n",
    "\n",
    "# Max of each artist\n",
    "r_max = r_stat.max()\n",
    "c_max = c_stat.max()\n",
    "\n",
    "# Min of each artist\n",
    "r_min = r_stat.min()\n",
    "c_min = c_stat.min()\n",
    "\n",
    "# Range of each artist\n",
    "r_range = r_max - r_min\n",
    "c_range = c_max - c_min\n",
    "\n",
    "# Number of bins\n",
    "r_bin = len(r_stat)\n",
    "c_bun = len(c_stat)\n",
    "\n",
    "print(\"Rihanna:\")\n",
    "print(\"Min:    {:.2f}\".format(r_min))\n",
    "print(\"Max:   {:.2f}\".format(r_max))\n",
    "print(\"Range: {:.2f}\".format(r_range))\n",
    "\n",
    "print(\"\\nCullum:\")\n",
    "print(\"Min:    {:.2f}\".format(c_min))\n",
    "print(\"Max:   {:.2f}\".format(c_max))\n",
    "print(\"Range: {:.2f}\".format(c_range))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bf3b80d",
   "metadata": {},
   "source": [
    "#### Statistics plot:\n",
    "Showing the mean, standard deviation and range of Rihanna's & Cullum's Spectral Centroid Mean "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75e0da57",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualizing\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16, 8), facecolor='#d3fbb5')\n",
    "\n",
    "fig.suptitle(\"H i s t o g r a m\", size='36', y=1.035, family='monospace')\n",
    "\n",
    "# Common title\n",
    "ax.set_title(r\"Rihanna: $\\mu={:.2f}$, $\\sigma={:.2f}$   —   Cullum: $\\mu={:.2f}$, $\\sigma={:.2f}$\".format(r_mu, r_sig, c_mu, c_sig), fontsize='20', y=1.04, family='monospace')\n",
    "ax.set_facecolor('#fef9e6')\n",
    "# Rihanna\n",
    "\n",
    "# the histogram of the data\n",
    "r_n, r_bins, r_patches = ax.hist(r_stat, bins=200, density=True, histtype='stepfilled', color='#f65f54', alpha=0.75)\n",
    "\n",
    "# add a trendy line\n",
    "r_y = ((1 / (np.sqrt(2 * np.pi) * r_sig)) *\n",
    "     np.exp(-0.5 * (1 / r_sig * (r_bins - r_mu))**2))\n",
    "ax.plot(r_bins, r_y, color='#f33224', ls='--', lw=3, label='Rihanna')\n",
    "\n",
    "ax.vlines((r_min, r_max), 0, r_n.max(), color='#f33224', alpha=0.9,\n",
    "           ls=':', lw=1.8, label='R-range')\n",
    "\n",
    "\n",
    "# Cullum\n",
    "\n",
    "# the histogram of the data\n",
    "c_n, c_bins, c_patches = ax.hist(c_stat, bins=200, density=True, histtype='stepfilled', color='#54ebf6', alpha=0.75)\n",
    "\n",
    "# add a trendy line\n",
    "c_y = ((1 / (np.sqrt(2 * np.pi) * c_sig)) *\n",
    "     np.exp(-0.5 * (1 / c_sig * (c_bins - c_mu))**2))\n",
    "ax.plot(c_bins, c_y, color='#6ca8f7', ls='--', lw=3, label='Cullum')\n",
    "\n",
    "ax.vlines((c_min, c_max), 0, c_n.max(), color='#6ca8f7', alpha=0.9,\n",
    "           ls=':', lw=1.8, label='C-range')\n",
    "\n",
    "ax.set_xlabel('Spectral Centroid Mean', fontsize='18', family='monospace')\n",
    "ax.set_ylabel('Probability density', fontsize='18', family='monospace')\n",
    "\n",
    "ax.set_xmargin(0.015)\n",
    "ax.legend(fontsize='20')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1af04549",
   "metadata": {},
   "source": [
    "## Metrics - stop\n",
    "Displaying the run time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9955941",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stop timer\n",
    "end = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae7258a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate total run time\n",
    "minutes = ((end-start) // 60)\n",
    "seconds = ((end-start) % 60)\n",
    "\n",
    "print(\"Total run time:\\t{m:1.0f} minutes and {s:.2f} seconds\".format(m = minutes, s = seconds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9b22245",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}