Knn_and_least_similar_song.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "0. Summary\n",
    "\n",
    "This notebook contains five parts:\n",
    "\n",
    "0.1.  Points 1 - 3 document the steps that were taken to create the training data of the model. \n",
    "      As this data can be found in the repository under \"./static/spotify.csv it could be simply loaded from there  if the user wishes to experiment with it.\n",
    "\n",
    "0.2. Points 4 -8 demonstrate the training of the knn-model and testing it by using the spotipy-api to generate input.\n",
    "\n",
    "0.3. Point 9 demonstrates the least similar song search using Numpy. \n",
    "\n",
    "0.4. Point 10 holds the code to get a 30 second demo of a song via the spotipy api. \n",
    "\n",
    "0.5. Point 11 includes a short discussion why we chose knn and did not opt for a neural net to achieve the target. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "\n",
    "df_2018 = pd.read_csv(\".\\data\\spotify_2018.csv\", encoding=\"latin1\")\n",
    "df_2019 = pd.read_csv(\".\\data\\spotify_2019.csv\", encoding=\"latin1\")\n",
    "df_2020 = pd.read_csv(\".\\data\\spotify_2020.csv\", encoding=\"latin1\")\n",
    "\n",
    "df = pd.concat([df_2018,df_2019,df_2020]).drop_duplicates().reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Datacleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove Nans\n",
    "df = df.dropna()\n",
    "\n",
    "# remove tracks that are most likely audiobooks, speeches etc\n",
    "\n",
    "df = df[(df.speechiness < 0.8)]\n",
    "\n",
    "# remove tracks with loudness > 0\n",
    "\n",
    "df = df[(df.loudness<=0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop_duplicates('track_id', keep='last')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Prepare data for training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save track Ids for future lookup\n",
    "IDS = df.track_id\n",
    "\n",
    "# provide features for training\n",
    "\n",
    "features = [\n",
    " 'danceability',\n",
    " 'energy',\n",
    " 'key',\n",
    " 'loudness',\n",
    " 'mode',\n",
    " 'speechiness',\n",
    " 'acousticness',\n",
    " 'instrumentalness',\n",
    " 'liveness',\n",
    " 'valence',\n",
    " 'tempo']\n",
    "\n",
    "X = df[features]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check that X and IDS are of the same length\n",
    "len(X.energy)  == len(IDS) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\UX490\\Anaconda3\\envs\\spotify\\lib\\site-packages\\pandas\\core\\generic.py:5303: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self[name] = value\n"
     ]
    }
   ],
   "source": [
    "# normalizing the data with MinMax scaler. This is implemented without sklearn to reduce \n",
    "# the size of the future upload\n",
    "\n",
    "\n",
    "X.key = X.key/(11)\n",
    "X.loudness = X.loudness/58.882\n",
    "X.tempo = X.tempo/249.983\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>danceability</th>\n",
       "      <th>energy</th>\n",
       "      <th>key</th>\n",
       "      <th>loudness</th>\n",
       "      <th>mode</th>\n",
       "      <th>speechiness</th>\n",
       "      <th>acousticness</th>\n",
       "      <th>instrumentalness</th>\n",
       "      <th>liveness</th>\n",
       "      <th>valence</th>\n",
       "      <th>tempo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>0.448</td>\n",
       "      <td>0.2560</td>\n",
       "      <td>0.454545</td>\n",
       "      <td>-0.172718</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0483</td>\n",
       "      <td>0.875</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.113</td>\n",
       "      <td>0.1740</td>\n",
       "      <td>0.309109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>0.664</td>\n",
       "      <td>0.0755</td>\n",
       "      <td>0.909091</td>\n",
       "      <td>-0.336877</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0389</td>\n",
       "      <td>0.910</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.164</td>\n",
       "      <td>0.5750</td>\n",
       "      <td>0.320038</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>51</th>\n",
       "      <td>0.652</td>\n",
       "      <td>0.4860</td>\n",
       "      <td>0.636364</td>\n",
       "      <td>-0.145308</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0382</td>\n",
       "      <td>0.220</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.177</td>\n",
       "      <td>0.3780</td>\n",
       "      <td>0.531740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>0.375</td>\n",
       "      <td>0.4300</td>\n",
       "      <td>0.363636</td>\n",
       "      <td>-0.165772</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0362</td>\n",
       "      <td>0.741</td>\n",
       "      <td>0.000024</td>\n",
       "      <td>0.093</td>\n",
       "      <td>0.2090</td>\n",
       "      <td>0.333459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>79</th>\n",
       "      <td>0.471</td>\n",
       "      <td>0.4690</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.179325</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0379</td>\n",
       "      <td>0.128</td>\n",
       "      <td>0.000020</td>\n",
       "      <td>0.132</td>\n",
       "      <td>0.0798</td>\n",
       "      <td>0.479461</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    danceability  energy       key  loudness  mode  speechiness  acousticness  \\\n",
       "36         0.448  0.2560  0.454545 -0.172718     1       0.0483         0.875   \n",
       "48         0.664  0.0755  0.909091 -0.336877     1       0.0389         0.910   \n",
       "51         0.652  0.4860  0.636364 -0.145308     0       0.0382         0.220   \n",
       "63         0.375  0.4300  0.363636 -0.165772     1       0.0362         0.741   \n",
       "79         0.471  0.4690  1.000000 -0.179325     1       0.0379         0.128   \n",
       "\n",
       "    instrumentalness  liveness  valence     tempo  \n",
       "36          0.000000     0.113   0.1740  0.309109  \n",
       "48          0.000000     0.164   0.5750  0.320038  \n",
       "51          0.000000     0.177   0.3780  0.531740  \n",
       "63          0.000024     0.093   0.2090  0.333459  \n",
       "79          0.000020     0.132   0.0798  0.479461  "
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save final training dataset for the repository\n",
    "X.to_csv(\"spotify.csv\", encoding='latin1', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Train the model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NearestNeighbors(algorithm='brute', leaf_size=30, metric='minkowski',\n",
       "                 metric_params=None, n_jobs=None, n_neighbors=6, p=2,\n",
       "                 radius=1.0)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "nn  = NearestNeighbors(n_neighbors=6, algorithm='brute')\n",
    "nn.fit(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Get example input with the spotipy api"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import spotipy\n",
    "from spotipy.oauth2 import SpotifyClientCredentials\n",
    "\n",
    "cid = \"361bfc4ba3d24781af18c0585594c1ff\"\n",
    "\n",
    "secret = \"c0f2fae0100243829516fe45298949c2\"\n",
    "\n",
    "client_credentials_manager = SpotifyClientCredentials(client_id=cid, client_secret=secret)\n",
    "sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager)\n",
    "\n",
    "song = sp.search(f'We are young fun', type='track', limit=1)\n",
    "song_id = song['tracks']['items'][0]['id']\n",
    "features_song = sp.audio_features([song_id])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a pandas dataframe that can be used for knn\n",
    "\n",
    "song = [[features_song[i] for i in features]]\n",
    "\n",
    "example = pd.DataFrame(song,\n",
    "\n",
    "                   columns=features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale the input with minmax\n",
    "\n",
    "example.key = example.key/(11)\n",
    "example.loudness = example.loudness/58.882\n",
    "example.tempo = example.tempo/249.983"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>danceability</th>\n",
       "      <th>energy</th>\n",
       "      <th>key</th>\n",
       "      <th>loudness</th>\n",
       "      <th>mode</th>\n",
       "      <th>speechiness</th>\n",
       "      <th>acousticness</th>\n",
       "      <th>instrumentalness</th>\n",
       "      <th>liveness</th>\n",
       "      <th>valence</th>\n",
       "      <th>tempo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.378</td>\n",
       "      <td>0.638</td>\n",
       "      <td>0.909091</td>\n",
       "      <td>-0.094698</td>\n",
       "      <td>1</td>\n",
       "      <td>0.075</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.000077</td>\n",
       "      <td>0.0849</td>\n",
       "      <td>0.735</td>\n",
       "      <td>0.736394</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   danceability  energy       key  loudness  mode  speechiness  acousticness  \\\n",
       "0         0.378   0.638  0.909091 -0.094698     1        0.075          0.02   \n",
       "\n",
       "   instrumentalness  liveness  valence     tempo  \n",
       "0          0.000077    0.0849    0.735  0.736394  "
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Make a prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance, ids = nn.kneighbors(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2KyeLD6a0JH1iWykA7uyvj\n",
      "6ly3yIQCvsoLjFKn1sVN0T\n",
      "4Pd5vQ9k3nGZtJshIneXSA\n",
      "3SRQ83CRFQ8uMRX7IsJp4N\n",
      "4LHvE4PjSvyOE0rInpU9C7\n",
      "4cOwNYxsajIGLJzoV845ec\n"
     ]
    }
   ],
   "source": [
    "# match provided indexes with track_ids\n",
    "for i in ids[0]:\n",
    "    print(IDS.iloc[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output in a list \n",
    "\n",
    "output = [IDS.iloc[i] for i in ids[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['72xcjEOojC20QH6LlqcdSi',\n",
       " '72xcjEOojC20QH6LlqcdSi',\n",
       " '2AaF78iCWISMWYog5RnSi5',\n",
       " '2AaF78iCWISMWYog5RnSi5',\n",
       " '06qEiiMjJKPCy5bmg47bCn',\n",
       " '06qEiiMjJKPCy5bmg47bCn']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Create a pickle of the model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spotify2.joblib']"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from joblib import dump\n",
    "\n",
    "dump(nn, 'spotify2.joblib')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Create csv for the lookup table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "IDS.to_csv(\"IDS2.csv\", encoding='latin1', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test the csv file\n",
    "\n",
    "test = pd.read_csv(\"./IDS2.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>track_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6lfxq3CG4xtTiEg7opyCyx</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>06JmNnH3iXKENNRKifqu0v</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7BXW1QCg56yzEBV8pW8pah</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4MZQ3lHA1TYO6yyedtmBYg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4m1lB7qJ78VPYsQy7RoBcU</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 track_id\n",
       "0  6lfxq3CG4xtTiEg7opyCyx\n",
       "1  06JmNnH3iXKENNRKifqu0v\n",
       "2  7BXW1QCg56yzEBV8pW8pah\n",
       "3  4MZQ3lHA1TYO6yyedtmBYg\n",
       "4  4m1lB7qJ78VPYsQy7RoBcU"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6lfxq3CG4xtTiEg7opyCyx\n",
       "1    06JmNnH3iXKENNRKifqu0v\n",
       "2    7BXW1QCg56yzEBV8pW8pah\n",
       "3    4MZQ3lHA1TYO6yyedtmBYg\n",
       "4    4m1lB7qJ78VPYsQy7RoBcU\n",
       "Name: track_id, dtype: object"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IDS.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Implementing least similar song search\n",
    "\n",
    "Knn does not provide a least similar neighbour functionality. However it is pretty straightforward to calculate the most distant point out of set of points from a given point using numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transforming the input data and the dataset to numpy arrays\n",
    "input_song = example.values\n",
    "data = X.values\n",
    "\n",
    "# define a function to calculate the distance between the input_song and \n",
    "# any other point from data. \n",
    "\n",
    "def myfunc(x):\n",
    "    return np.linalg.norm(input_song-x)\n",
    "\n",
    "# apply the function to each row of data = every song that was used to train knn\n",
    "\n",
    "distances = np.apply_along_axis(myfunc, axis=1, arr=data)\n",
    "\n",
    "# retrieve the index of the maximum distance in distances\n",
    "\n",
    "index_least_similar_song = np.where(distances == np.amax(distances))[0][0]\n",
    "\n",
    "# get corresponding track_id\n",
    "\n",
    "track_id = IDS.iloc[index_least_similar_song]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6pZs7ObmFRDgcF1nz83iTx'"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "track_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. Get a 30 second demo of a song via spotipy with a track_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "song = sp.track(\"spotify:track:6pZs7ObmFRDgcF1nz83iTx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://p.scdn.co/mp3-preview/4de084dacae3ed9027e7747305337c9f2bdffd66?cid=361bfc4ba3d24781af18c0585594c1ff'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "song[\"preview_url\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'7a86XRg84qjasly9f6bPSD'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "song_id\n",
    "\n",
    "# see 5. of this notebook for the origin of song_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://p.scdn.co/mp3-preview/af96d9b11588ea7d7754ccf2a8cefa7ead23a7d6?cid=361bfc4ba3d24781af18c0585594c1ff'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "song_opposite = sp.track(\"spotify:track:7a86XRg84qjasly9f6bPSD\")\n",
    "song_opposite[\"preview_url\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11. Reasoning to not use a neural net\n",
    "\n",
    "- Neural nets do not work better than traditional algorithms on tabular numeric data.\n",
    "\n",
    "- One could argue that the key- and the mode-column in the dataset holds categorcal values. However given the specific way knn functions there was no reason to treat those values as categorical. \n",
    "\n",
    "- as this is a student project and does not have a budget the primary option for deployment is Heroku. However Heroku is known to not function well with Tensorflow and often enough neural nets are simply too big to be implemented on Heroku. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Spotify (Python3)",
   "language": "python",
   "name": "spotify"
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}