create_playlist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Playlist with Type 1 Error Songs  \n",
    "This notebook creates a playlist with all songs from the random sample from kaggle that are incorrectly labeled as songs from my personal listening history.  If the songs are from the random sample but the model thinks that the song characteristics are in line with my personal listening data then I might like the song!  And in fact this playlist has helped me discover many new artists that I had never heard of and several songs that I love but haven't heard or thought about in years.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "import xgboost\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from datetime import datetime\n",
    "from datetime import date\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "import requests\n",
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_master = pd.read_csv('data/spotify_personal_kaggle.csv', sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train the model with the hyperparameters that performed best in the model_building notebook.  \n",
    "# Returns an array y_pred with predictions that can be used to find all type 1 errors. \n",
    "y = df_master['y']\n",
    "\n",
    "X = df_master\n",
    "rs = 22\n",
    "X_train_, X_other, y_train, y_other = train_test_split(X, y, test_size=0.4, random_state=rs, shuffle = True, stratify= y)\n",
    "X_val_, X_test_, y_val, y_test = train_test_split(X_other, y_other, test_size=0.5, random_state=rs, shuffle = True, stratify= y_other)\n",
    "X_train = X_train_.drop(['artistName', 'trackName', 'y'], axis=1)\n",
    "\n",
    "X_val = X_val_.drop(['artistName', 'trackName', 'y'], axis=1)\n",
    "X_test = X_test_.drop(['artistName', 'trackName', 'y'], axis=1)\n",
    "\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = pd.DataFrame(scaler.fit_transform(X_train))\n",
    "X_train.columns = X_train.columns\n",
    "\n",
    "X_val = pd.DataFrame(scaler.transform(X_val))\n",
    "X_val.columns = X_train.columns\n",
    "\n",
    "X_test = pd.DataFrame(scaler.transform(X_test))\n",
    "X_test.columns = X_train.columns\n",
    "\n",
    "cl = xgboost.XGBClassifier(n_estimators = 32, max_depth = 10, reg_alpha=10, reg_lambda=0, use_label_encoder=False,random_state=rs)\n",
    "cl.fit(X_train, y_train, eval_metric='logloss')\n",
    "y_pred = cl.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create dictionary with all type 1 errors - songs classified as being from my history but actually from random sample\n",
    "type_1 = [i for i in range(len(y_test)) if y_test.iloc[i] == 0 and y_pred[i] == 1]\n",
    "d = {X_test_['trackName'].iloc[i]: X_test_['artistName'].iloc[i] for i in type_1}\n",
    "d[\"Im with You\"] = d[\"I'm with You\"] \n",
    "del d[\"I'm with You\"]\n",
    "d[\"Youll Be In My Heart - Instrumental\"] = d[\"You'll Be In My Heart - Instrumental\"]\n",
    "del d[\"You'll Be In My Heart - Instrumental\"]\n",
    "d[\"Dont Cry (Original)\"] = \"Guns N Roses\"\n",
    "del d[\"Don't Cry (Original)\"]\n",
    "d[\"Wholl Stop The Rain\"] = d[\"Who'll Stop The Rain\"]\n",
    "del d[\"Who'll Stop The Rain\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize class with spotify_token, spotify_id and a dictionary of all songs.  The populate_playlist\n",
    "# method will create and populate the playlist.  \n",
    "\n",
    "class type_1_playlist: #partially adapted from https://github.com/TheComeUpCode/SpotifyGeneratePlaylist/blob/master/create_playlist.py\n",
    "    \"\"\"this class creates a playlist of all type 1 errors using spotify api\"\"\"\n",
    "    def __init__(self, spotify_token, spotify_user_id, song_dict):\n",
    "        self.spotify_token = spotify_token\n",
    "        self.spotify_user_id = spotify_user_id\n",
    "        self.song_dict = song_dict\n",
    "        \n",
    "    def _get_spotify_uri(self, song_name, artist): \n",
    "        \"\"\"returns the uri of particular song\"\"\"\n",
    "        query = \"https://api.spotify.com/v1/search?query=track%3A{}+artist%3A{}&type=track&offset=0&limit=20\".format(\n",
    "            song_name,\n",
    "            artist\n",
    "        )\n",
    "        response = requests.get(\n",
    "            query,\n",
    "            headers={\n",
    "                \"Content-Type\": \"application/json\",\n",
    "                \"Authorization\": \"Bearer {}\".format(self.spotify_token)\n",
    "            }\n",
    "        )\n",
    "        response_json = response.json()\n",
    "        songs = response_json[\"tracks\"][\"items\"]\n",
    "        uri = songs[0][\"uri\"]\n",
    "\n",
    "        return uri\n",
    "    \n",
    "    def _create_uri_list(self):\n",
    "        \"\"\"creates a list of all uri for song list\"\"\"\n",
    "        uri_list = []\n",
    "        for key in self.song_dict:\n",
    "            try:\n",
    "                uri_list.append(self._get_spotify_uri(key, self.song_dict[key]))\n",
    "            except:\n",
    "                print(key, self.song_dict[key])\n",
    "        return uri_list\n",
    "    \n",
    "    def create_playlist(self):\n",
    "        \"\"\"Create A New Playlist\"\"\"\n",
    "        request_body = json.dumps({\n",
    "            \"name\": \"Type 1 Error\",\n",
    "            \"description\": \"All Misclassified Songs from Kaggle\",\n",
    "            \"public\": True\n",
    "        })\n",
    "\n",
    "        query = \"https://api.spotify.com/v1/users/{}/playlists\".format(\n",
    "            self.spotify_user_id)\n",
    "        response = requests.post(\n",
    "            query,\n",
    "            data=request_body,\n",
    "            headers={\n",
    "                \"Content-Type\": \"application/json\",\n",
    "                \"Authorization\": \"Bearer {}\".format(self.spotify_token)\n",
    "            }\n",
    "        )\n",
    "        response_json = response.json()\n",
    "\n",
    "        # playlist id\n",
    "        return response_json[\"id\"]\n",
    "    \n",
    "    def populate_playlist(self):\n",
    "        \"\"\"Add all type 1 error songs to playlist\"\"\"\n",
    " \n",
    "        uris = self._create_uri_list()\n",
    "        \n",
    "        playlist_id = self.create_playlist()\n",
    "        \n",
    "        temp_list = uris[0:100]\n",
    "        request_data = json.dumps(temp_list)\n",
    "\n",
    "        query = \"https://api.spotify.com/v1/playlists/{}/tracks\".format(\n",
    "            playlist_id)\n",
    "\n",
    "        response = requests.post(\n",
    "            query,\n",
    "            data=request_data,\n",
    "            headers={\n",
    "                \"Content-Type\": \"application/json\",\n",
    "                \"Authorization\": \"Bearer {}\".format(self.spotify_token)\n",
    "            }\n",
    "        )\n",
    "\n",
    "        # check for valid response status\n",
    "        if response.status_code != 200:\n",
    "            print(response.status_code)\n",
    "            \n",
    "\n",
    "        response_json = response.json()\n",
    "        return response_json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "spotify_token = # add spotify token which can be found on spotify for developers\n",
    "spotify_id = # add spotify id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "201\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'snapshot_id': 'Myw5OTAxMTczOWJiODRjNzA5YTM4YmVlMTJmNGY0ODY4NGYzMTcyNjNl'}"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl = type_1_playlist(spotify_token, spotify_id, d)\n",
    "pl.populate_playlist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}