NNCF_prediction_rand_lowValLoss.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Making Song Recommendation with Neural Collaborative Filtering**\n",
    "\n",
    "***\n",
    "With the neural network collaborative filtering (NNCF), we were able to make song recommendation for existing playlists. Here we used the NNCF model trained on the subset of data with randomly selected 10,000 playlists and demonstrated how we recommend new songs to those existing playlists. \n",
    "<br/><br/>\n",
    "The idea is to choose the songs that have the highest scores predicted by the network when paired with a specific playlist. We can then compute the Jaccard index of recommended songs and existing songs, and compare it to the Jaccard index between existing songs, and that between not-recommended songs and exisiting songs. A good recommendation would have a high Jaccard index (comparable to Jaccard index between existing songs).\n",
    "\n",
    "***\n",
    "First we load all the libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import statsmodels.api as sm\n",
    "import scipy.sparse as sps\n",
    "import scipy\n",
    "import pickle\n",
    "import keras\n",
    "from keras.models import load_model\n",
    "import itertools\n",
    "%matplotlib inline\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data and model\n",
    "\n",
    "***\n",
    "Here we loaded the sparse matrix containing track-playlist contingency, as well as the NNCF model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<171381x10000 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 657056 stored elements in Compressed Sparse Column format>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load files\n",
    "sps_acc = scipy.sparse.load_npz('sparse_10000_rand.npz')\n",
    "\n",
    "# convert matrix to csc type\n",
    "sps_acc = sps_acc.tocsc()\n",
    "sps_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the best NNCF model\n",
    "model_file = \"models_10000_rand/model.200-0.50-0.76.h5\"\n",
    "model = load_model(model_file)\n",
    "\n",
    "# find track and playlist number\n",
    "n_tracks, n_playlists = sps_acc.shape[0], sps_acc.shape[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define functions\n",
    "***\n",
    "Then we define several functions.\n",
    "\n",
    "- ***recommend_tracks***\n",
    "This function makes recommendation of tracks that are not currently in a specific playlist. It returns the list of tracks that were predicted by the network as class 1 but have real label class 0, sorted by the score.\n",
    "\n",
    "- ***get_jaccard***\n",
    "This function calculated the Jaccard index between a pair of tracks.\n",
    "\n",
    "- ***create_unique_pair_subset*** and ***create_pairs_btw_lists*** help creating pairs of tracks from given lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function returns the indices and scores for recommeded tracks given a playlist_id\n",
    "def recommend_tracks(sps_acc, playlist_ind, model):\n",
    "    pairs = [np.ones((n_tracks,))*playlist_ind, np.arange(n_tracks)]\n",
    "\n",
    "    # make prediction with the model\n",
    "    prob = model.predict(pairs)\n",
    "    pred_class = prob.argmax(axis=-1)\n",
    "\n",
    "    # extract real class label from original data\n",
    "    real_class = np.array(sps_acc[:,playlist_ind].toarray()).reshape(-1,)\n",
    "    \n",
    "    # real tracks: real class one\n",
    "    real_one_ind = np.argwhere(real_class).reshape(-1,)\n",
    "    \n",
    "    # recommended tracks: predicted class one but real class zero\n",
    "    recom = np.logical_and(pred_class == 1, real_class == 0)\n",
    "\n",
    "    # find recommeded track index and score of being one\n",
    "    recom_ind = np.argwhere(recom).reshape(-1,)\n",
    "    recom_prob = prob[recom_ind,1]\n",
    "\n",
    "    # sort recommended indices from highest score to lowest\n",
    "    recom_sort_ind = np.argsort(recom_prob)\n",
    "    recom_ind = recom_ind[recom_sort_ind[::-1]]\n",
    "\n",
    "    # not-recommended tracks: predicted class zero and real class zero\n",
    "    not_recom = np.logical_and(pred_class == 0, real_class == 0)\n",
    "\n",
    "    # find not-recommeded track index and score of being zero\n",
    "    not_recom_ind = np.argwhere(not_recom).reshape(-1,)\n",
    "    not_recom_prob = prob[not_recom_ind,0]\n",
    "\n",
    "    # sort not-recommended indices from highest score to lowest\n",
    "    not_recom_sort_ind = np.argsort(not_recom_prob)\n",
    "    not_recom_ind = not_recom_ind[not_recom_sort_ind[::-1]]\n",
    "\n",
    "\n",
    "    return recom_ind, not_recom_ind, real_one_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function return jaccard index between a pair of tracks\n",
    "def get_jaccard(sps_acc, pair):\n",
    "    pair = list(pair)\n",
    "    track1 = pair[0]\n",
    "    track2 = pair[1]\n",
    "\n",
    "    mem = np.array(sps_acc[pair,:].toarray())\n",
    "\n",
    "    mem1 = np.argwhere(mem[0,:]).reshape(-1,)\n",
    "    mem2 = np.argwhere(mem[1,:]).reshape(-1,)\n",
    "\n",
    "    intersect = list(set(mem1) & set(mem2))\n",
    "    union = list(set(mem1) | set(mem2))\n",
    "    jaccard = len(intersect)/len(union)\n",
    "    \n",
    "    return jaccard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function creates a subset of unique pair of a given list of tracks\n",
    "def create_unique_pair_subset(track_list, num):\n",
    "    track_list = list(track_list)\n",
    "    track_pairs = [(track1, track2) for i, track1 in enumerate(track_list) \n",
    "               for j, track2 in enumerate(track_list) if i<j]\n",
    "    total_num = len(track_pairs)\n",
    "    if total_num > num:\n",
    "        sub_ind = list(np.random.choice(total_num, num, replace=False))\n",
    "        track_pair_subset = [pair for idx, pair in enumerate(track_pairs) if idx in sub_ind]\n",
    "    else:\n",
    "        track_pair_subset = track_pairs\n",
    "    \n",
    "    return track_pair_subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function creates all pairs between 2 given lists of tracks\n",
    "def create_pairs_btw_lists(track_list1, track_list2):\n",
    "    track_list1 = list(track_list1)\n",
    "    track_list2 = list(track_list2)\n",
    "    track_pairs = [(track1, track2) for track1 in track_list1 for track2 in track_list2]\n",
    "    return track_pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make recommendation for one playlist\n",
    "***\n",
    "Here we randomly selecte a playlist, and make recommendation of the top 10 songs with the highest scores predicted by the NNCF model. We then compute Jaccard index between the recommended songs and existing songs (***rec vs. real***), and compare that to Jaccard index between exisitng songs (***btw real***), and Jaccard index between exisitng songs and 10 randomly selected non-recommended songs (***not-rec vs. real***). Jaccard inex for ***Rrandom pairs*** of tracks was also computed as baseline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Jaccard index\n",
      " rec vs. real = 0.0081430460371861 \n",
      " btw real = 0.03138652210942226 \n",
      " not_rec vs. real 6.969834556041452e-05 \n",
      " random pair 0.00015164196090215217\n"
     ]
    }
   ],
   "source": [
    "# randomly select one playlist and make recommendation\n",
    "playlist_id = np.random.choice(n_playlists, 1)[0]\n",
    "\n",
    "# number of recommended tracks\n",
    "num_rec = 10\n",
    "\n",
    "# get recommendation from NN model\n",
    "rec, not_rec, real = recommend_tracks(sps_acc, playlist_id, model)\n",
    "\n",
    "# restrict number of real tracks to no more than 50\n",
    "if real.shape[0] > 50:\n",
    "    real = real[np.random.choice(real.shape[0], 50, replace=False)]\n",
    "\n",
    "# select rec and not_rec\n",
    "rec = rec[:num_rec]\n",
    "not_rec = not_rec[np.random.choice(not_rec.shape[0], num_rec, replace=False)]\n",
    "\n",
    "# calculate the pair number\n",
    "pair_num = real.shape[0]*num_rec\n",
    "\n",
    "# collect jaccard index for rec-real pairs\n",
    "rec_real_pairs = create_pairs_btw_lists(rec, real)\n",
    "rec_real_jac = [get_jaccard(sps_acc,i) for i in rec_real_pairs]\n",
    "\n",
    "# collect jaccard index for real-real pairs\n",
    "real_real_pairs = create_unique_pair_subset(real, pair_num)\n",
    "real_real_jac = [get_jaccard(sps_acc,i) for i in real_real_pairs]\n",
    "\n",
    "# collect jaccard index for not_rec-real pairs\n",
    "not_rec_real_pairs = create_pairs_btw_lists(not_rec, real)\n",
    "not_rec_real_jac = [get_jaccard(sps_acc,i) for i in not_rec_real_pairs]\n",
    "\n",
    "# random pairs\n",
    "rand_pair_num = 100\n",
    "rand_id = list(np.random.choice(n_tracks, 2*rand_pair_num))\n",
    "rand_pairs = [(tr1,tr2) for tr1 in rand_id[:rand_pair_num] \n",
    "              for tr2 in rand_id[rand_pair_num+1:] if tr1<tr2]\n",
    "rand_jac = [get_jaccard(sps_acc,i) for i in rand_pairs]\n",
    "\n",
    "print('Mean Jaccard index\\n rec vs. real =',np.mean(rec_real_jac),\n",
    "      '\\n btw real =',np.mean(real_real_jac),\n",
    "      '\\n not_rec vs. real',np.mean(not_rec_real_jac),\n",
    "      '\\n random pair',np.mean(rand_jac))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize result\n",
    "***\n",
    "We can visualize the distribution of Jaccard index of 4 groups by plotting their empirical cumulative density functions. As we can see here, the ***rec vs. real*** group and ***btw real*** have distributions of higher Jaccard index, meaning that the tracks are similar to each other (even more similar for ***rec vs. real*** than ***btw real***), whereas the Jaccard index for ***not-rec vs. real*** group was really close to zero, comparable to ***random pairs*** of tracks. Therefore, the recommendation seems to be working well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize distribution of Jaccard index\n",
    "ecdf1 = sm.distributions.ECDF(real_real_jac)\n",
    "x1 = np.linspace(0, max(real_real_jac),1000)\n",
    "y1 = ecdf1(x1)\n",
    "plt.step(x1, y1,label='btw Real')\n",
    "\n",
    "ecdf2 = sm.distributions.ECDF(rec_real_jac)\n",
    "y2 = ecdf2(x1)\n",
    "plt.step(x1, y2,label='Rec vs. Real')\n",
    "\n",
    "ecdf3 = sm.distributions.ECDF(not_rec_real_jac)\n",
    "x3 = np.linspace(0, max(real_real_jac),10000)\n",
    "y3 = ecdf3(x3)\n",
    "plt.step(np.concatenate((np.zeros(1,),x3)), np.concatenate((np.zeros(1,),y3)),label='Not-rec vs. Real')\n",
    "\n",
    "ecdf4 = sm.distributions.ECDF(rand_jac)\n",
    "y4 = ecdf4(x3)\n",
    "plt.step(np.concatenate((np.zeros(1,),x3)), np.concatenate((np.zeros(1,),y4)),label='Random pair')\n",
    "\n",
    "plt.legend(loc='best')\n",
    "plt.title('Cumulative distribution of Jaccard index',fontsize = 15)\n",
    "plt.xlabel('Jaccard index',fontsize = 15)\n",
    "plt.ylabel('Cumulative density',fontsize = 15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scale up for 100 playlists\n",
    "***\n",
    "We can scale up our recommendation to 100 randomly selected playlists and look at the statistics of the Jaccard index of each group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load random playlist subset that was used for SVD\n",
    "with open('playlist_id_100_for_jaccard_SVD_rand.pkl','rb') as f1:\n",
    "    playlist_subset = pickle.load(f1)\n",
    "    \n",
    "# create empty lists\n",
    "mean_rec_real_jac = []\n",
    "mean_real_real_jac = []\n",
    "mean_not_rec_real_jac = []\n",
    "mean_rand_jac = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over playlist subset to get jaccard index\n",
    "for ii, playlist_id in enumerate(playlist_subset):\n",
    "    # specify number of recommendation (=10 songs)\n",
    "    num_rec = 10\n",
    "    \n",
    "    # get recommendation from NN model\n",
    "    rec, not_rec, real = recommend_tracks(sps_acc, playlist_id, model)\n",
    "\n",
    "    # restrict number of real tracks to no more than 50\n",
    "    if real.shape[0] > 50:\n",
    "        real = real[np.random.choice(real.shape[0], 50, replace=False)]\n",
    "\n",
    "    # select rec and not_rec\n",
    "    rec = rec[:num_rec]\n",
    "    not_rec = not_rec[np.random.choice(not_rec.shape[0], num_rec, replace=False)]\n",
    "    \n",
    "    # calculate the pair number\n",
    "    pair_num = real.shape[0]*num_rec\n",
    "\n",
    "    # collect jaccard index for rec-real pairs\n",
    "    rec_real_pairs = create_pairs_btw_lists(rec, real)\n",
    "    rec_real_jac = [get_jaccard(sps_acc,i) for i in rec_real_pairs]\n",
    "    mean_rec_real_jac.append(np.mean(rec_real_jac))\n",
    "\n",
    "    # collect jaccard index for real-real pairs\n",
    "    real_real_pairs = create_unique_pair_subset(real, pair_num)\n",
    "    real_real_jac = [get_jaccard(sps_acc,i) for i in real_real_pairs]\n",
    "    mean_real_real_jac.append(np.mean(real_real_jac))\n",
    "\n",
    "    # collect jaccard index for not_rec-real pairs\n",
    "    not_rec_real_pairs = create_pairs_btw_lists(not_rec, real)\n",
    "    not_rec_real_jac = [get_jaccard(sps_acc,i) for i in not_rec_real_pairs]\n",
    "    mean_not_rec_real_jac.append(np.mean(not_rec_real_jac))\n",
    "    \n",
    "    # random pairs\n",
    "    rand_pair_num = 100\n",
    "    rand_id = list(np.random.choice(n_tracks, 2*rand_pair_num))\n",
    "    rand_pairs = [(tr1,tr2) for tr1 in rand_id[:rand_pair_num] \n",
    "                  for tr2 in rand_id[rand_pair_num+1:] if tr1<tr2]\n",
    "    rand_jac = [get_jaccard(sps_acc,i) for i in rand_pairs]\n",
    "    mean_rand_jac.append(np.mean(rand_jac))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization \n",
    "***\n",
    "The boxplot below shows the distribution of mean Jaccard index of the 4 groups for the 100 playlists. The ***btw real*** had the highest Jaccard index, indicating high similarity between each pair. The ***rec vs. real*** had low but above zero Jaccard index. Jaccard index for ***not-rec vs. real group*** was close zero, showing low similarity (as ***random pairs*** of tracks). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# result visualization\n",
    "# put results into dataframe\n",
    "all_jac = np.concatenate((np.array(mean_real_real_jac),\n",
    "                          np.array(mean_rec_real_jac),\n",
    "                          np.array(mean_not_rec_real_jac),\n",
    "                          np.array(mean_rand_jac)))\n",
    "label = np.concatenate((np.ones(100,),np.ones(100,)*2,\n",
    "                        np.ones(100,)*3,np.ones(100,)*4))\n",
    "jac_df = pd.DataFrame({'jac':all_jac, 'label': label})\n",
    "\n",
    "# plot boxplot\n",
    "ax = sns.boxplot(x='label', y='jac', data=jac_df)\n",
    "plt.xticks([0.,1.,2.,3.], ['btw Real','Rec vs. Real','Not-rec vs. Real','Random pair'],\n",
    "           fontsize = 15, rotation = 45)\n",
    "plt.ylim([-0.01, 0.5])\n",
    "plt.title('Boxplot: Mean Jaccard index',fontsize = 15)\n",
    "plt.xlabel('')\n",
    "plt.ylabel('Mean Jaccard index',fontsize = 15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zoomed in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.boxplot(x='label', y='jac', data=jac_df)\n",
    "plt.xticks([0.,1.,2.,3.], ['btw Real','Rec vs. Real','Not-rec vs. Real','Random pair'],\n",
    "           fontsize = 15, rotation = 45)\n",
    "plt.ylim([-0.01, 0.09])\n",
    "plt.title('Boxplot: Mean Jaccard index',fontsize = 15)\n",
    "plt.xlabel('')\n",
    "plt.ylabel('Mean Jaccard index',fontsize = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put result into a dict and save it\n",
    "jaccard_dict = {}\n",
    "jaccard_dict['rec_real'] = mean_rec_real_jac\n",
    "jaccard_dict['real_real'] = mean_real_real_jac\n",
    "jaccard_dict['not_rec_real'] = mean_not_rec_real_jac\n",
    "jaccard_dict['rand_pair'] = mean_rand_jac\n",
    "\n",
    "with open('jaccard_100_playlists_NNCF10000_rand.pkl','wb') as f0:\n",
    "    pickle.dump(jaccard_dict, f0)\n",
    "with open('playlist_id_100_for_jaccard_NNCF10000_rand.pkl','wb') as f1:\n",
    "    pickle.dump(playlist_subset, f1)"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}