Practice 3 - Content Based Filtering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recommender Systems 2019/20\n",
    "\n",
    "### Practice 3 - Content Based recommenders\n",
    "\n",
    "\n",
    "### Load the data you saw last time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlretrieve\n",
    "import zipfile, os\n",
    "\n",
    "# If file exists, skip the download\n",
    "data_file_path = \"data/Movielens_10M/\"\n",
    "data_file_name = data_file_path + \"movielens_10m.zip\"\n",
    "\n",
    "# If directory does not exist, create\n",
    "if not os.path.exists(data_file_path):\n",
    "    os.makedirs(data_file_path)\n",
    "\n",
    "if not os.path.exists(data_file_name):\n",
    "    urlretrieve (\"http://files.grouplens.org/datasets/movielens/ml-10m.zip\", data_file_name)\n",
    "    \n",
    "dataFile = zipfile.ZipFile(data_file_name)\n",
    "URM_path = dataFile.extract(\"ml-10M100K/ratings.dat\", path=\"data/Movielens_10M\")\n",
    "URM_file = open(URM_path, 'r')\n",
    "\n",
    "\n",
    "def rowSplit (rowString):\n",
    "    \n",
    "    split = rowString.split(\"::\")\n",
    "    split[3] = split[3].replace(\"\\n\",\"\")\n",
    "    \n",
    "    split[0] = int(split[0])\n",
    "    split[1] = int(split[1])\n",
    "    split[2] = float(split[2])\n",
    "    split[3] = int(split[3])\n",
    "    \n",
    "    result = tuple(split)\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    "URM_file.seek(0)\n",
    "URM_tuples = []\n",
    "\n",
    "for line in URM_file:\n",
    "   URM_tuples.append(rowSplit (line))\n",
    "\n",
    "userList, itemList, ratingList, timestampList = zip(*URM_tuples)\n",
    "\n",
    "userList = list(userList)\n",
    "itemList = list(itemList)\n",
    "ratingList = list(ratingList)\n",
    "timestampList = list(timestampList)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User data, ID: min 1, max 71567, unique 69878, missig 2.36 %\n",
      "Item data, ID: min 1, max 65133, unique 10677, missig 83.61 %\n"
     ]
    }
   ],
   "source": [
    "def list_ID_stats(ID_list, label):\n",
    "    \n",
    "    min_val = min(ID_list)\n",
    "    max_val = max(ID_list)\n",
    "    unique_val = len(set(ID_list))\n",
    "    missing_val = 1 - unique_val/(max_val - min_val)\n",
    "\n",
    "    print(\"{} data, ID: min {}, max {}, unique {}, missig {:.2f} %\".format(label, min_val, max_val, unique_val, missing_val*100))\n",
    "\n",
    "    \n",
    "    \n",
    "list_ID_stats(userList, \"User\")\n",
    "list_ID_stats(itemList, \"Item\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.sparse as sps\n",
    "\n",
    "URM_all = sps.coo_matrix((ratingList, (userList, itemList)))\n",
    "URM_all = URM_all.tocsr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For items in particular most have no interactions. Sometimes it may be better to remove them to avoid creating big data structures with no need. In this case empty columns will nave no impact and we leave them as is. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## And now load the content informations in the same way:\n",
    "## In this case we are using tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ICM_path = dataFile.extract(\"ml-10M100K/tags.dat\", path = \"data/Movielens_10M\")\n",
    "ICM_file = open(ICM_path, 'r')\n",
    "\n",
    "def rowSplit (rowString):\n",
    "    split = rowString.split(\"::\")\n",
    "    split[3] = split[3].replace(\"\\n\",\"\")\n",
    "    \n",
    "    split[0] = int(split[0])\n",
    "    split[1] = int(split[1])\n",
    "    split[2] = str(split[2]) # tag is a string, not a float like the rating\n",
    "    split[3] = int(split[3])\n",
    "    \n",
    "    result = tuple(split)\n",
    "    \n",
    "    return result\n",
    "\n",
    "ICM_file.seek(0)\n",
    "ICM_tuples = []\n",
    "\n",
    "for line in ICM_file:\n",
    "    ICM_tuples.append(rowSplit(line))\n",
    "    \n",
    "userList_icm, itemList_icm, tagList_icm, timestampList_icm = zip(*ICM_tuples)\n",
    "\n",
    "userList_icm = list(userList_icm)\n",
    "itemList_icm = list(itemList_icm)\n",
    "tagList_icm = list(tagList_icm)\n",
    "timestampList_icm = list(timestampList_icm)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Users ICM data, ID: min 15, max 71556, unique 4009, missig 94.40 %\n",
      "Items ICM data, ID: min 1, max 65130, unique 7601, missig 88.33 %\n"
     ]
    }
   ],
   "source": [
    "list_ID_stats(userList_icm, \"Users ICM\")\n",
    "list_ID_stats(itemList_icm, \"Items ICM\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We can see that most users and items have no data associated to them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of tags\t 16529, Number of item-tag tuples 95580\n",
      "\n",
      "Data example:\n",
      "[15, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n",
      "[4973, 1747, 1747, 2424, 2424, 2424, 2947, 2947, 3033, 3033]\n",
      "['excellent!', 'politics', 'satire', 'chick flick 212', 'hanks', 'ryan', 'action', 'bond', 'spoof', 'star wars']\n"
     ]
    }
   ],
   "source": [
    "numTags = len(set(tagList_icm))\n",
    "\n",
    "print (\"Number of tags\\t {}, Number of item-tag tuples {}\".format(numTags, len(tagList_icm)))\n",
    "\n",
    "print(\"\\nData example:\")\n",
    "print(userList_icm[0:10])\n",
    "print(itemList_icm[0:10])\n",
    "print(tagList_icm[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The numbers of items and users in the ICM matrix is different from what we saw in the URM, why?\n",
    "\n",
    "### The tags are string, we should traslate them into numbers so we can use them as indices in the ICM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9814 13375 14131  8515 10769 14070  7015  8071 14829 14900]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "le = preprocessing.LabelEncoder()\n",
    "le.fit(tagList_icm)\n",
    "\n",
    "tagList_icm = le.transform(tagList_icm)\n",
    "\n",
    "print(tagList_icm[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# We can now build the ICM\n",
    "\n",
    "#### Be careful with the indices!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<65134x16529 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 71155 stored elements in Compressed Sparse Row format>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n_items = URM_all.shape[1]\n",
    "n_tags = max(tagList_icm) + 1\n",
    "\n",
    "ICM_shape = (n_items, n_tags)\n",
    "\n",
    "ones = np.ones(len(tagList_icm))\n",
    "ICM_all = sps.coo_matrix((ones, (itemList_icm, tagList_icm)), shape = ICM_shape)\n",
    "ICM_all = ICM_all.tocsr()\n",
    "\n",
    "ICM_all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's take a look at the ICM\n",
    "\n",
    "### We leverage CSR and CSC indptr data structure to compute the number of cells that have values for that row or column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ICM_all = sps.csr_matrix(ICM_all)\n",
    "features_per_item = np.ediff1d(ICM_all.indptr)\n",
    "\n",
    "ICM_all = sps.csc_matrix(ICM_all)\n",
    "items_per_feature = np.ediff1d(ICM_all.indptr)\n",
    "\n",
    "ICM_all = sps.csr_matrix(ICM_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(65134,)\n",
      "(16529,)\n"
     ]
    }
   ],
   "source": [
    "print(features_per_item.shape)\n",
    "print(items_per_feature.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_per_item = np.sort(features_per_item)\n",
    "items_per_feature = np.sort(items_per_feature)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": [
    "import matplotlib.pyplot as pyplot\n",
    "%matplotlib inline  \n",
    "\n",
    "pyplot.plot(features_per_item, 'ro')\n",
    "pyplot.ylabel('Num features ')\n",
    "pyplot.xlabel('Item Index')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": [
    "pyplot.plot(items_per_feature, 'ro')\n",
    "pyplot.ylabel('Num items ')\n",
    "pyplot.xlabel('Feature Index')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# We can now build the recommender algorithm, but first we need the train/test split and the evaluation function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Notebooks_utils.data_splitter import train_test_holdout\n",
    "\n",
    "\n",
    "URM_train, URM_test = train_test_holdout(URM_all, train_perc = 0.8)\n",
    "\n",
    "\n",
    "from Notebooks_utils.evaluation_function import evaluate_algorithm\n",
    "from Base.Similarity.Compute_Similarity_Python import Compute_Similarity_Python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ItemCBFKNNRecommender(object):\n",
    "    \n",
    "    def __init__(self, URM, ICM):\n",
    "        self.URM = URM\n",
    "        self.ICM = ICM\n",
    "        \n",
    "            \n",
    "    def fit(self, topK=50, shrink=100, normalize = True, similarity = \"cosine\"):\n",
    "        \n",
    "        similarity_object = Compute_Similarity_Python(self.ICM.T, shrink=shrink, \n",
    "                                                  topK=topK, normalize=normalize, \n",
    "                                                  similarity = similarity)\n",
    "        \n",
    "        self.W_sparse = similarity_object.compute_similarity()\n",
    "\n",
    "        \n",
    "    def recommend(self, user_id, at=None, exclude_seen=True):\n",
    "        # compute the scores using the dot product\n",
    "        user_profile = self.URM[user_id]\n",
    "        scores = user_profile.dot(self.W_sparse).toarray().ravel()\n",
    "\n",
    "        if exclude_seen:\n",
    "            scores = self.filter_seen(user_id, scores)\n",
    "\n",
    "        # rank items\n",
    "        ranking = scores.argsort()[::-1]\n",
    "            \n",
    "        return ranking[:at]\n",
    "    \n",
    "    \n",
    "    def filter_seen(self, user_id, scores):\n",
    "\n",
    "        start_pos = self.URM.indptr[user_id]\n",
    "        end_pos = self.URM.indptr[user_id+1]\n",
    "\n",
    "        user_profile = self.URM.indices[start_pos:end_pos]\n",
    "        \n",
    "        scores[user_profile] = -np.inf\n",
    "\n",
    "        return scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We need to define Cosine similarity... Let's look at the attached source code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### See also a [list of commonly used KNN similarity heuristics](https://github.com/MaurizioFD/RecSys_Course_2018/blob/master/slides/List_of_KNN_similarity_heuristics.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test our CBF recommender:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 28900 ( 44 % ), 959.58 column/sec, elapsed time 0.50 min\n",
      "Similarity column 56100 ( 86 % ), 932.43 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 941.12 column/sec, elapsed time 1.15 min\n"
     ]
    }
   ],
   "source": [
    "recommender = ItemCBFKNNRecommender(URM_train, ICM_all)\n",
    "recommender.fit(shrink=0.0, topK=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8636  153 6333  592 1591]\n",
      "[1036  153 8636 1591 5378]\n",
      "[65133 21706 21719 21718 21717]\n",
      "[ 6350 62336  5971  2810  5378]\n",
      "[1026 8525 2043 2566 5651]\n",
      "[65133 21706 21719 21718 21717]\n",
      "[65133 21706 21719 21718 21717]\n",
      "[ 260 1196   22 2461 8525]\n",
      "[41566  3086  4901  1619  4161]\n",
      "[65133 21706 21719 21718 21717]\n"
     ]
    }
   ],
   "source": [
    "userList_unique = list(set(userList_icm))\n",
    "for user_id in userList_unique[0:10]:\n",
    "    print(recommender.recommend(user_id, at=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's talk about speed\n",
    "\n",
    "#### Time to compute recommendations for a fixed group of users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reasonable implementation speed is 407.76 usr/sec\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "n_users_to_test = 1000\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "for user_id in range(n_users_to_test):\n",
    "    recommender.recommend(user_id, at=5)\n",
    "    \n",
    "end_time = time.time()\n",
    "\n",
    "print(\"Reasonable implementation speed is {:.2f} usr/sec\".format(n_users_to_test/(end_time-start_time)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's add a common mistake.... a CSC URM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 29000 ( 45 % ), 966.19 column/sec, elapsed time 0.50 min\n",
      "Similarity column 57300 ( 88 % ), 954.67 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 941.27 column/sec, elapsed time 1.15 min\n"
     ]
    }
   ],
   "source": [
    "URM_train_csc = URM_train.tocsc()\n",
    "\n",
    "recommender = ItemCBFKNNRecommender(URM_train_csc, ICM_all)\n",
    "recommender.fit(shrink=0.0, topK=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception index 65135 is out of bounds for axis 0 with size 65134\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-20-cd8883de5544>\", line 10, in <module>\n",
      "    recommender.recommend(user_id, at=5)\n",
      "  File \"<ipython-input-15-d625b194ca44>\", line 23, in recommend\n",
      "    scores = self.filter_seen(user_id, scores)\n",
      "  File \"<ipython-input-15-d625b194ca44>\", line 38, in filter_seen\n",
      "    scores[user_profile] = -np.inf\n",
      "IndexError: index 65135 is out of bounds for axis 0 with size 65134\n"
     ]
    }
   ],
   "source": [
    "import time, traceback\n",
    "\n",
    "try:\n",
    "\n",
    "    n_users_to_test = 1000\n",
    "\n",
    "    start_time = time.time()\n",
    "\n",
    "    for user_id in range(n_users_to_test):\n",
    "        recommender.recommend(user_id, at=5)\n",
    "\n",
    "    end_time = time.time()\n",
    "\n",
    "    print(\"Wrong implementation speed is {:.2f} usr/sec\".format(n_users_to_test/(end_time-start_time)))\n",
    "\n",
    "    \n",
    "except Exception as e:\n",
    "        \n",
    "    print(\"Exception {}\".format(str(e)))\n",
    "    traceback.print_exc()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameter tuning\n",
    "\n",
    "#### Once we have built our model we can play with its parameters\n",
    "* Number of neighbors\n",
    "* Shrinkage\n",
    "* Similarity type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of neighbors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 27500 ( 42 % ), 914.30 column/sec, elapsed time 0.50 min\n",
      "Similarity column 55100 ( 85 % ), 916.06 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 917.65 column/sec, elapsed time 1.18 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0924, Recall = 0.0203, MAP = 0.0612\n",
      "Similarity column 19100 ( 29 % ), 634.86 column/sec, elapsed time 0.50 min\n",
      "Similarity column 38500 ( 59 % ), 639.12 column/sec, elapsed time 1.00 min\n",
      "Similarity column 58400 ( 90 % ), 646.91 column/sec, elapsed time 1.50 min\n",
      "Similarity column 65134 ( 100 % ), 654.12 column/sec, elapsed time 1.66 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0773, Recall = 0.0169, MAP = 0.0545\n",
      "Similarity column 22800 ( 35 % ), 759.78 column/sec, elapsed time 0.50 min\n",
      "Similarity column 45500 ( 70 % ), 757.02 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 757.98 column/sec, elapsed time 1.43 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0816, Recall = 0.0179, MAP = 0.0574\n",
      "Similarity column 20800 ( 32 % ), 692.58 column/sec, elapsed time 0.50 min\n",
      "Similarity column 39500 ( 61 % ), 657.62 column/sec, elapsed time 1.00 min\n",
      "Similarity column 62700 ( 96 % ), 695.69 column/sec, elapsed time 1.50 min\n",
      "Similarity column 65134 ( 100 % ), 693.92 column/sec, elapsed time 1.56 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0881, Recall = 0.0194, MAP = 0.0606\n",
      "Similarity column 17200 ( 26 % ), 571.32 column/sec, elapsed time 0.50 min\n",
      "Similarity column 35800 ( 55 % ), 595.13 column/sec, elapsed time 1.00 min\n",
      "Similarity column 56300 ( 86 % ), 624.37 column/sec, elapsed time 1.50 min\n",
      "Similarity column 65134 ( 100 % ), 635.17 column/sec, elapsed time 1.71 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0888, Recall = 0.0203, MAP = 0.0603\n"
     ]
    }
   ],
   "source": [
    "x_tick = [10, 50, 100, 200, 500]\n",
    "MAP_per_k = []\n",
    "\n",
    "for topK in x_tick:\n",
    "    \n",
    "    recommender = ItemCBFKNNRecommender(URM_train, ICM_all)\n",
    "    recommender.fit(shrink=0.0, topK=topK)\n",
    "    \n",
    "    result_dict = evaluate_algorithm(URM_test, recommender)\n",
    "    MAP_per_k.append(result_dict[\"MAP\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": [
    "pyplot.plot(x_tick, MAP_per_k)\n",
    "pyplot.ylabel('MAP')\n",
    "pyplot.xlabel('TopK')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### On this dataset the number of neighbors does not have a great impact on MAP. Higher values of TopK might work even better\n",
    "\n",
    "#### Different datasets will behave in different ways."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shrinkage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 23000 ( 35 % ), 766.49 column/sec, elapsed time 0.50 min\n",
      "Similarity column 46100 ( 71 % ), 767.47 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 741.87 column/sec, elapsed time 1.46 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0816, Recall = 0.0179, MAP = 0.0574\n",
      "Similarity column 22300 ( 34 % ), 742.80 column/sec, elapsed time 0.50 min\n",
      "Similarity column 44700 ( 69 % ), 744.63 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 739.30 column/sec, elapsed time 1.47 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1196, Recall = 0.0253, MAP = 0.0868\n",
      "Similarity column 21600 ( 33 % ), 717.53 column/sec, elapsed time 0.50 min\n",
      "Similarity column 44900 ( 69 % ), 746.83 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 757.81 column/sec, elapsed time 1.43 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1377, Recall = 0.0288, MAP = 0.1007\n",
      "Similarity column 14600 ( 22 % ), 484.91 column/sec, elapsed time 0.50 min\n",
      "Similarity column 34400 ( 53 % ), 572.19 column/sec, elapsed time 1.00 min\n",
      "Similarity column 53700 ( 82 % ), 595.30 column/sec, elapsed time 1.50 min\n",
      "Similarity column 65134 ( 100 % ), 594.14 column/sec, elapsed time 1.83 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1468, Recall = 0.0305, MAP = 0.1083\n",
      "Similarity column 20700 ( 32 % ), 687.40 column/sec, elapsed time 0.50 min\n",
      "Similarity column 42400 ( 65 % ), 704.56 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 730.95 column/sec, elapsed time 1.49 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1555, Recall = 0.0322, MAP = 0.1157\n",
      "Similarity column 22300 ( 34 % ), 742.01 column/sec, elapsed time 0.50 min\n",
      "Similarity column 45400 ( 70 % ), 754.55 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 726.09 column/sec, elapsed time 1.50 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1637, Recall = 0.0339, MAP = 0.1230\n"
     ]
    }
   ],
   "source": [
    "x_tick = [0, 10, 50, 100, 200, 500]\n",
    "MAP_per_shrinkage = []\n",
    "\n",
    "for shrink in x_tick:\n",
    "    \n",
    "    recommender = ItemCBFKNNRecommender(URM_train, ICM_all)\n",
    "    recommender.fit(shrink=shrink, topK=100)\n",
    "    \n",
    "    result_dict = evaluate_algorithm(URM_test, recommender)\n",
    "    MAP_per_shrinkage.append(result_dict[\"MAP\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": [
    "pyplot.plot(x_tick, MAP_per_shrinkage)\n",
    "pyplot.ylabel('MAP')\n",
    "pyplot.xlabel('Shrinkage')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The shrinkage value (i.e. support) have a much stronger impact. Combine a parameter search with the two to ensure maximum recommendation quality\n",
    "\n",
    "## Be careful, overfitting!\n",
    "\n",
    "#### While a thorough parameter tuning might result in significantly higher MAP on your validation split, it could have only marginally better or even worse MAP on the test set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature weighting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# IDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](https://www.link-assistant.com/images/news/tf-idf-tool-for-seo/screen-03.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(65134, 16529)\n",
      "(16529,)\n"
     ]
    }
   ],
   "source": [
    "num_tot_items = ICM_all.shape[0]\n",
    "\n",
    "# let's count how many items have a certain feature\n",
    "items_per_feature = (ICM_all > 0).sum(axis=0)\n",
    "\n",
    "IDF = np.array(np.log(num_tot_items / items_per_feature))[0]\n",
    "\n",
    "print(ICM_all.shape)\n",
    "print(IDF.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(16529,)\n",
      "(65134, 16529)\n",
      "(16529,)\n"
     ]
    }
   ],
   "source": [
    "ICM_idf = ICM_all.copy()\n",
    "# compute the number of non-zeros in each col\n",
    "# NOTE: this works only if X is instance of sparse.csc_matrix\n",
    "col_nnz = np.diff(sps.csc_matrix(ICM_idf).indptr)\n",
    "print(col_nnz.shape)\n",
    "print(ICM_idf.shape)\n",
    "print(IDF.shape)\n",
    "# then normalize the values in each col\n",
    "ICM_idf.data *= np.repeat(IDF, col_nnz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 20900 ( 32 % ), 693.43 column/sec, elapsed time 0.50 min\n",
      "Similarity column 40700 ( 62 % ), 675.35 column/sec, elapsed time 1.00 min\n",
      "Similarity column 61000 ( 94 % ), 675.22 column/sec, elapsed time 1.51 min\n",
      "Similarity column 65134 ( 100 % ), 672.11 column/sec, elapsed time 1.62 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0792, Recall = 0.0172, MAP = 0.0558\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'precision': 0.0792412281329945,\n",
       " 'recall': 0.01719270671397733,\n",
       " 'MAP': 0.05577713464283948}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recommender_idf = ItemCBFKNNRecommender(URM_train, ICM_idf)\n",
    "recommender_idf.fit(shrink=0.0, topK=50)\n",
    "\n",
    "evaluate_algorithm(URM_test, recommender_idf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There is  a small gain over the non-weighted ICM. Try other feature weighting methods like BM25..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BM25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Base.IR_feature_weighting import okapi_BM_25\n",
    "\n",
    "ICM_BM25 = ICM_all.copy().astype(np.float32)\n",
    "ICM_BM25 = okapi_BM_25(ICM_BM25)\n",
    "ICM_BM25 = ICM_BM25.tocsr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity column 21700 ( 33 % ), 721.95 column/sec, elapsed time 0.50 min\n",
      "Similarity column 45300 ( 70 % ), 752.51 column/sec, elapsed time 1.00 min\n",
      "Similarity column 65134 ( 100 % ), 762.50 column/sec, elapsed time 1.42 min\n",
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.0805, Recall = 0.0180, MAP = 0.0559\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'precision': 0.08049056549706429,\n",
       " 'recall': 0.017977736637926213,\n",
       " 'MAP': 0.055879630292923775}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recommender_bm25 = ItemCBFKNNRecommender(URM_train, ICM_BM25)\n",
    "recommender_bm25.fit(shrink=0.0, topK=50)\n",
    "\n",
    "evaluate_algorithm(URM_test, recommender_bm25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Another small gain over TF-IDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unnormalized similarity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluated user 0 of 71568\n",
      "Evaluated user 10000 of 71568\n",
      "Evaluated user 20000 of 71568\n",
      "Evaluated user 30000 of 71568\n",
      "Evaluated user 40000 of 71568\n",
      "Evaluated user 50000 of 71568\n",
      "Evaluated user 60000 of 71568\n",
      "Evaluated user 70000 of 71568\n",
      "Recommender performance is: Precision = 0.1735, Recall = 0.0364, MAP = 0.1333\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'precision': 0.17354327549896595,\n",
       " 'recall': 0.036350178495898736,\n",
       " 'MAP': 0.13328965507910867}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recommender_dot = ItemCBFKNNRecommender(URM_train, ICM_all)\n",
    "recommender_dot.W_sparse = ICM_all * ICM_all.T\n",
    "\n",
    "evaluate_algorithm(URM_test, recommender_dot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Be careful when you use user tags as content..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}