recommender.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the notebook for initial testing out of and experimentation with the recommendation system. Code is finally refined and broken into `preprocessing.py` and `recommender.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Installing all needed libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install numpy\n",
    "%pip install pandas\n",
    "%pip install sklearn\n",
    "%pip install seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing the installed libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading and preprocessing the music data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('spotify_songs.csv')\n",
    "data = data[data['language'] == 'en']\n",
    "data.drop(columns=['language', 'playlist_name', 'playlist_id'], inplace=True)\n",
    "data = data.drop_duplicates(subset=['track_name', 'track_artist'])\n",
    "data['track_album_release_date'] = pd.to_datetime(data['track_album_release_date'], infer_datetime_format=True)\n",
    "data = data.sort_values(by=['track_album_release_date'])\n",
    "data.reset_index(drop=True, inplace=True)\n",
    "print(data.columns)\n",
    "songs_count = data.shape[0]\n",
    "print(songs_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sectioning off data for recommendation subsystems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lyrics_data = data['lyrics']\n",
    "energy_data = data[['danceability', 'tempo', 'acousticness']]\n",
    "mood_data = data[['mode', 'key', 'valence']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using cosine similarity and Tfidf for making lyrics comparable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "lyric_vectorizer = TfidfVectorizer(stop_words='english')\n",
    "lyrics_data = lyric_vectorizer.fit_transform(lyrics_data)\n",
    "lyric_similarity_matrix = cosine_similarity(lyrics_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using euclidean distance for making energy and mood comparable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics.pairwise import euclidean_distances\n",
    "\n",
    "energy_difference_matrix = euclidean_distances(energy_data)\n",
    "mood_difference_matrix = euclidean_distances(mood_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utility functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_by_popularity(songs, descending=True):\n",
    "    if descending:\n",
    "        return songs.sort_values(by=['track_popularity'])[::-1]\n",
    "    else:\n",
    "        return songs.sort_values(by=['track_popularity'])\n",
    "\n",
    "\n",
    "def get_similar(track_index, count, comparison_matrix, select_smallest):\n",
    "    similar_songs_indexes = np.argsort(np.array(comparison_matrix[track_index]))\n",
    "    similar_songs_indexes = np.delete(similar_songs_indexes, np.where(similar_songs_indexes == track_index))\n",
    "    similar_songs_indexes = similar_songs_indexes[:count] if select_smallest else similar_songs_indexes[::-1][:count]\n",
    "    return data.iloc[similar_songs_indexes].copy()\n",
    "\n",
    "\n",
    "def songs_as_dict(songs, include_fields):\n",
    "    return songs[include_fields].to_dict(orient='index')\n",
    "\n",
    "\n",
    "def get_closest_n(track_index, count):\n",
    "    if track_index >= count//2 and track_index < songs_count-count//2:\n",
    "        return pd.concat([data.iloc[track_index-count//2 : track_index], data.iloc[track_index+1 : track_index+count//2+1]])\n",
    "    elif track_index < count//2:\n",
    "        return data.head(count+1).drop(track_index)\n",
    "    else:\n",
    "        return data.tail(count+1).drop(track_index)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getters for recommendation subsystems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_by_same_artist(track_index, count):\n",
    "    return data[data['track_artist'] == data.iloc[track_index]['track_artist']].drop(track_index)[:count]\n",
    "\n",
    "\n",
    "def get_lyrically_similar(track_index, count):\n",
    "    return get_similar(track_index, count, lyric_similarity_matrix, False)\n",
    "\n",
    "\n",
    "def get_energy_similar(track_index, count):\n",
    "    return get_similar(track_index, count, energy_difference_matrix, True)\n",
    "\n",
    "\n",
    "def get_mood_similar(track_index, count):\n",
    "    return get_similar(track_index, count, mood_difference_matrix, True)\n",
    "\n",
    "\n",
    "def get_random(count):\n",
    "    return data.sample(count)\n",
    "\n",
    "\n",
    "def get_released_around_same_time(track_index, count):\n",
    "    return get_closest_n(track_index, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recommendation subsytems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recommend_by_same_artist(track_index, count, prioritisePopular):\n",
    "    songs_by_same_artist = get_by_same_artist(track_index, count)\n",
    "    songs_by_same_artist['recommendation_type'] = 'by same artist'\n",
    "    return sort_by_popularity(songs_by_same_artist, prioritisePopular)\n",
    "\n",
    "\n",
    "def recommend_lyrically_similar(track_index, count, prioritisePopular):\n",
    "    similar_songs = get_lyrically_similar(track_index, count)\n",
    "    similar_songs['recommendation_type'] = 'lyrically similar'\n",
    "    return sort_by_popularity(similar_songs, prioritisePopular)\n",
    "\n",
    "\n",
    "def recommend_energy_similar(track_index, count, prioritisePopular):\n",
    "    similar_songs = get_energy_similar(track_index, count)\n",
    "    similar_songs['recommendation_type'] = 'similar energy'\n",
    "    return sort_by_popularity(similar_songs, prioritisePopular)\n",
    "\n",
    "\n",
    "def recommend_mood_similar(track_index, count, prioritisePopular):\n",
    "    similar_songs = get_mood_similar(track_index, count)\n",
    "    similar_songs['recommendation_type'] = 'similar mood'\n",
    "    return sort_by_popularity(similar_songs, prioritisePopular)\n",
    "\n",
    "\n",
    "def recommend_released_around_same_time(track_index, count, prioritisePopular):\n",
    "    contemporary_songs = get_released_around_same_time(track_index, count)\n",
    "    contemporary_songs['recommendation_type'] = 'released around same time'\n",
    "    return sort_by_popularity(contemporary_songs, prioritisePopular)\n",
    "\n",
    "\n",
    "def recommend_random(count, prioritisePopular):\n",
    "    random_songs = get_random(count)\n",
    "    random_songs['recommendation_type'] = 'random'\n",
    "    return sort_by_popularity(random_songs, prioritisePopular)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hybrid recommendation system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hybrid_recommend(track_index, count=6, prioritisePopular=True):\n",
    "    by_same_artist = recommend_by_same_artist(track_index, count, prioritisePopular)\n",
    "    lyrically_similar = recommend_lyrically_similar(track_index, count, prioritisePopular)\n",
    "    energy_similar = recommend_energy_similar(track_index, count, prioritisePopular)\n",
    "    mood_similar = recommend_mood_similar(track_index, count, prioritisePopular)\n",
    "    random = recommend_random(count, prioritisePopular)\n",
    "    released_around_same_time = recommend_released_around_same_time(track_index, count, prioritisePopular)\n",
    "    all_recommendations = pd.concat([by_same_artist, lyrically_similar, energy_similar, mood_similar, random, released_around_same_time]).drop_duplicates()\n",
    "    return songs_as_dict(all_recommendations, include_fields=['track_name', 'track_artist', 'recommendation_type'])\n",
    "\n",
    "hybrid_recommend(4982)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testing / visualization\n",
    "data[data['track_artist'] == 'Taylor Swift']\n",
    "\n",
    "# data.iloc[2274]\n",
    "\n",
    "# sb.displot(data=data, x='track_album_release_date')\n",
    "# data[data['track_artist'] == 'Queen'].head(30)\n",
    "# sonic_data.describe()\n",
    "\n",
    "# data['track_artist'].value_counts()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "369f2c481f4da34e4445cda3fffd2e751bd1c4d706f27375911949ba6bb62e1c"
  },
  "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}