ml1m_pagerank.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from ordered_set import OrderedSet\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction\n",
    "\n",
    "1. We will implement PageRank algorithm on knowledge graph built on ML1M dataset. \n",
    "2. We will directly read the gpickle file that we saved in the notebook named [ml1m_kg_networkx](https://github.com/rajatguptakgp/practical_machine_learning/blob/main/ml1m_kg_networkx.ipynb)\n",
    "3. We will consider the PageRank scores for movies to rank them for generating predictions for users. Note that the predictions here are same for all users based on decreasing movie pagerank scores and so we do not expect recommendation metrics to be good, but we can also calculate something called as **Personalized PageRank (PPR)** for each user that highlights their preference for different movies. Also, no rating has been considered for predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# config\n",
    "alpha = 0.8\n",
    "n_iter = 1000\n",
    "seed = 42\n",
    "graph_path = 'ml1m.gpickle'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pagerank_matrix(G, alpha):\n",
    "    n_nodes = len(G.nodes())\n",
    "\n",
    "    # building adjacent matrix\n",
    "    adj_matrix = np.zeros(shape=(n_nodes, n_nodes))\n",
    "    for edge in G.edges():\n",
    "        adj_matrix[edge[0], edge[1]] = 1\n",
    "\n",
    "    # building transition probability matrix\n",
    "    tran_matrix = adj_matrix / np.sum(adj_matrix, axis=1).reshape(-1,1)\n",
    "    tran_matrix = np.nan_to_num(tran_matrix)\n",
    "    \n",
    "    # building random surfer matrix\n",
    "    random_surf = np.ones(shape = (n_nodes, n_nodes)) / n_nodes    \n",
    "\n",
    "    # building transition matrix for absorbing nodes\n",
    "    absorbing_nodes = np.zeros(shape = (n_nodes,))\n",
    "    for node in G.nodes():\n",
    "        if len(G.successors(node))==0:\n",
    "            absorbing_nodes[node] = 1\n",
    "    absorbing_node_matrix = np.outer(absorbing_nodes, np.ones(shape = (n_nodes,))) / n_nodes\n",
    "\n",
    "    # stochastic matrix\n",
    "    stochastic_matrix = tran_matrix + absorbing_node_matrix\n",
    "\n",
    "    # pagerank matrix\n",
    "    pagerank_matrix = alpha * stochastic_matrix + (1-alpha) * random_surf\n",
    "    return pagerank_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_walk(G, alpha, n_iter):\n",
    "    n_nodes = len(G.nodes())\n",
    "    initial_state = np.ones(shape=(n_nodes,)) / n_nodes\n",
    "    pagerank_matrix = make_pagerank_matrix(G, alpha)\n",
    "\n",
    "    new_initial_state = initial_state\n",
    "    print('Running random walk..')\n",
    "    NORM = []\n",
    "    for i in tqdm(range(n_iter)):\n",
    "        final_state = np.dot(np.transpose(pagerank_matrix), new_initial_state)\n",
    "        \n",
    "        prev_initial_state = new_initial_state\n",
    "        new_initial_state = final_state\n",
    "        L2 = np.linalg.norm(new_initial_state-prev_initial_state)\n",
    "        NORM.append(L2)\n",
    "        if np.allclose(new_initial_state, prev_initial_state):\n",
    "            print(f'Converged at {i+1} iterations..')\n",
    "            break\n",
    "\n",
    "    plt.figure(figsize=(5,4))\n",
    "    plt.plot(range(i+1), NORM)\n",
    "    plt.xlabel('iterations')\n",
    "    plt.ylabel('Euclidean Norm')\n",
    "    plt.title('Convergence plot')\n",
    "    plt.show()\n",
    "    return final_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(G, alpha, n_iter):\n",
    "    final_probs = random_walk(G, alpha, n_iter)\n",
    "\n",
    "    # ensuring pagerank importance for each node\n",
    "    assert len(final_probs) == len(G.nodes())\n",
    "\n",
    "    # ensuring probabilities sum to 1\n",
    "    assert np.allclose(np.sum(final_probs), 1)\n",
    "\n",
    "    return final_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of nodes:  9940\n",
      "Number of edges:  1511854\n",
      "\n",
      "Relabelling nodes to integers..\n",
      "Running random walk..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▍         | 46/1000 [00:02<00:48, 19.85it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converged at 47 iterations..\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# loading networkx graph\n",
    "G = nx.read_gpickle(graph_path)\n",
    "\n",
    "print('Number of nodes: ', len(G.nodes()))\n",
    "print('Number of edges: ', len(G.edges()))\n",
    "\n",
    "print()\n",
    "print('Relabelling nodes to integers..')\n",
    "n_unique_nodes = len(set(G.nodes()))\n",
    "node2int = dict(zip(set(G.nodes()), range(n_unique_nodes)))\n",
    "int2node = {v:k for k,v in node2int.items()}\n",
    "# input for pagerank\n",
    "G = nx.relabel_nodes(G, node2int)\n",
    "final_probs = run(G, alpha, n_iter)\n",
    "\n",
    "# back to original nodes\n",
    "G = nx.relabel_nodes(G, int2node)\n",
    "pagerank_scores_dict = dict(zip(G.nodes(), final_probs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('ml-1m/movies.dat','r', encoding=\"ISO-8859-1\") as f:\n",
    "    data = f.read().splitlines()\n",
    "\n",
    "data = list(map(lambda x: x.split('::'), data))\n",
    "movies_df = pd.DataFrame(data, columns = ['movieID','title','genres'])\n",
    "movies_df['movieID'] = movies_df['movieID'].astype('int')\n",
    "movieID2name = dict(zip(movies_df['movieID'].values, movies_df['title'].values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('ml-1m/ratings.dat','r', encoding=\"ISO-8859-1\") as f:\n",
    "    data = f.read().splitlines()\n",
    "\n",
    "data = list(map(lambda x: x.split('::'), data))\n",
    "ratings_df = pd.DataFrame(data, columns = ['userID','movieID','rating','timestamp'])\n",
    "ratings_df[['userID','movieID','rating']] = ratings_df[['userID','movieID','rating']].astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((900188, 4), (100021, 4))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# splitting data into training and validation split for recommendation\n",
    "# using same split (seed) which was used in creating the knowledge graph\n",
    "ratings_df, ratings_val = train_test_split(ratings_df, test_size=0.1, random_state=42)\n",
    "ratings_df.shape, ratings_val.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top 5 rated movies based on pagerank scores..\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Simon Birch (1998)',\n",
       " 'In the Company of Men (1997)',\n",
       " \"Schindler's List (1993)\",\n",
       " 'Big (1988)',\n",
       " \"Puppet Master III: Toulon's Revenge (1991)\"]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranking = []\n",
    "for node, score in pagerank_scores_dict.items():\n",
    "    if isinstance(node, int) and node>0:\n",
    "        ranking.append([node, score])\n",
    "\n",
    "# sorting movies in decreasing order of pagerank scores\n",
    "# this list serves as top movie recommendations for any user\n",
    "sorted_movies = np.array(sorted(ranking, key=lambda x:x[1], reverse=True)).astype('int')[:, 0].tolist()\n",
    "\n",
    "print('Top 5 rated movies based on pagerank scores..')\n",
    "list(map(lambda x: movieID2name[x], sorted_movies))[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_predictions(ratings_df, ratings_val, sorted_movies):\n",
    "    \"\"\" \n",
    "    for users predictions will be made for movies \n",
    "    which they have not rated from training set\n",
    "    \"\"\"\n",
    "    \n",
    "    # check for users present in validation and training set\n",
    "    commonIDs = set(ratings_val['userID']) and set(ratings_df['userID'])\n",
    "    uncommonIDs = set(ratings_val['userID']) - set(ratings_df['userID'])\n",
    "\n",
    "    rated_movies_dict = dict(ratings_df.groupby('userID')['movieID'].apply(lambda x: set(x)))\n",
    "    \n",
    "    # sorted set for movies\n",
    "    sorted_movies_set = OrderedSet(sorted_movies)\n",
    "    pred = dict(zip(commonIDs, map(lambda x: list(sorted_movies_set - rated_movies_dict[x]), commonIDs)))\n",
    "    if uncommonIDs:\n",
    "        pred2 = {}\n",
    "        pred2 = dict(zip(uncommonIDs, [sorted_movies]*len(uncommonIDs)))\n",
    "        pred.update(pred2)\n",
    "    return pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_eval_data(ratings_val):\n",
    "    gt = {}\n",
    "    pred = {}\n",
    "    ratings_val = ratings_val.reset_index(drop=True)\n",
    "\n",
    "    # getting ground truth data\n",
    "    for idx in range(len(ratings_val)):\n",
    "        userID = ratings_val.loc[idx, 'userID']\n",
    "        movieID = ratings_val.loc[idx, 'movieID']\n",
    "        rating = ratings_val.loc[idx, 'rating']\n",
    "        if gt.get(userID):\n",
    "            gt[userID].append([movieID, rating])\n",
    "        else:\n",
    "            gt[userID] = [[movieID, rating]]\n",
    "\n",
    "    # sorting movies according to ratings\n",
    "    for k, v in gt.items():\n",
    "        gt[k] = np.array(sorted(gt[k], key = lambda x: x[1], reverse=True)).astype('int')[:, 0].tolist()    \n",
    "\n",
    "    # getting predictions based on pagerank scores\n",
    "    pred = get_predictions(ratings_df, ratings_val, sorted_movies)            \n",
    "    return gt, pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Order unaware metrics:\n",
    "1. Hit@K\n",
    "2. Precision@K\n",
    "3. Recall@K\n",
    "4. F1@K\n",
    "\n",
    "#### Order aware metrics:\n",
    "1. MRR@K\n",
    "\n",
    "For more information: [Recommendation Evaluation Metrics](https://github.com/rajatguptakgp/ml_from_scratch/blob/master/recommendation_evaluation_metrics.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hit_k(act, pred, k):\n",
    "    act_set = set(act)\n",
    "    pred_set = set(pred[:k])   \n",
    "    common_set = act_set & pred_set   \n",
    "    if (len(common_set)>0):\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "def precision_k(act, pred, k):\n",
    "    act_set = set(act)\n",
    "    pred_set = set(pred[:k])    \n",
    "    common_set = act_set & pred_set   \n",
    "    if len(pred_set)==0:\n",
    "        return 0\n",
    "    else:\n",
    "        return len(common_set) / len(pred_set)\n",
    "\n",
    "def recall_k(act, pred, k):\n",
    "    act_set = set(act)\n",
    "    pred_set = set(pred[:k])   \n",
    "    common_set = act_set & pred_set\n",
    "    if len(act_set)==0:\n",
    "        return 0\n",
    "    else:\n",
    "        return len(common_set) / len(act_set)\n",
    "\n",
    "def mean_reciprocal_rank_k(act, pred, k):\n",
    "    found = 0\n",
    "    for i in range(len(pred)):\n",
    "        if pred[i] in act[:k]:\n",
    "            found = 1\n",
    "            break\n",
    "    if found:\n",
    "        mrr = 1 / (i+1)\n",
    "    else:\n",
    "        mrr = 0\n",
    "    return mrr\n",
    "\n",
    "# overall MRR\n",
    "def mean_reciprocal_rank(gt, predictions):\n",
    "    def find_reciprocal_rank(act, pred):\n",
    "        pred = np.array(pred)\n",
    "        for p in pred:\n",
    "            if p in act:\n",
    "                rank = np.where(pred==p)[0][0] + 1\n",
    "                return 1/rank\n",
    "        return 0\n",
    "    return np.mean(list(map(lambda x, y: find_reciprocal_rank(x, y), gt, predictions)))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_scores(metric):    \n",
    "    values_normalized = []\n",
    "    for v in metric.values():\n",
    "        values_normalized.append(v[0]/max(v[1],1))\n",
    "    return values_normalized\n",
    "    \n",
    "def get_recommendation_metrics(gt, pred):\n",
    "    hit = {}\n",
    "    rec = {}\n",
    "    prec = {}\n",
    "    mrr = {}\n",
    "\n",
    "    topK = [5, 10, 20, 50, 100, 200]\n",
    "    for i in topK:\n",
    "        hit[i] = [0, 0]\n",
    "        rec[i] = [0, 0]\n",
    "        prec[i] = [0, 0]\n",
    "        mrr[i] = [0, 0]\n",
    "\n",
    "    for user in gt.keys():\n",
    "        for topk in rec.keys():\n",
    "            # if number of predictions are less than topK, skip \n",
    "            if len(pred[user])<topk:\n",
    "                break\n",
    "\n",
    "            h = hit_k(gt[user], pred[user], topk)\n",
    "            r = recall_k(gt[user], pred[user], topk)\n",
    "            p = precision_k(gt[user], pred[user], topk)\n",
    "            m = mean_reciprocal_rank_k(gt[user], pred[user], topk)\n",
    "\n",
    "            hit[topk] = [hit[topk][0]+h, hit[topk][1]+1]\n",
    "            rec[topk] = [rec[topk][0]+r, rec[topk][1]+1]\n",
    "            prec[topk] = [prec[topk][0]+p, prec[topk][1]+1]\n",
    "            mrr[topk] = [mrr[topk][0]+m, mrr[topk][1]+1]\n",
    "\n",
    "    labels=['Precision@K','Recall@K','Hit@K','MRR@K']\n",
    "    metrics=[prec,rec,hit,mrr]\n",
    "    df_scores = pd.DataFrame(index=topK, columns=['Precision@K','Recall@K','F1@K','Hit@K','MRR@K'])\n",
    "    for label, metric in zip(labels, metrics):\n",
    "        scores = calculate_scores(metric)\n",
    "        df_scores[label]=scores\n",
    "    df_scores['F1@K']=(2 * df_scores['Recall@K'] * df_scores['Precision@K'])/(df_scores['Recall@K'] + df_scores['Precision@K'])\n",
    "    df_scores = df_scores.reset_index()\n",
    "    df_scores.rename(columns={'index':'K'}, inplace=True)\n",
    "    return df_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_plot(df_scores,label):\n",
    "    X=df_scores.K\n",
    "    Y=df_scores[label].values\n",
    "    \n",
    "    plt.title(f'{label}')\n",
    "    plt.xlabel('K')\n",
    "    plt.ylabel('Values')\n",
    "    plt.xticks(X)\n",
    "    plt.plot(X,Y,c='k',linestyle='--',marker='o')\n",
    "    return plt\n",
    "\n",
    "def plotting(df_scores):\n",
    "    fig=plt.figure(figsize=(17, 5), dpi= 80, facecolor='w', edgecolor='k')\n",
    "    plt.subplot(131)\n",
    "    plt1 = return_plot(df_scores,'Precision@K')\n",
    "    plt.subplot(132)\n",
    "    plt2 = return_plot(df_scores,'Recall@K')\n",
    "    plt.subplot(133)\n",
    "    plt3 = return_plot(df_scores,'F1@K')\n",
    "    plt.show()\n",
    "\n",
    "    fig=plt.figure(figsize=(18, 5), dpi= 80, facecolor='w', edgecolor='k')\n",
    "    plt.subplot(121)\n",
    "    plt4 = return_plot(df_scores,'Hit@K')\n",
    "    plt.subplot(122)\n",
    "    plt5 = return_plot(df_scores,'MRR@K')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting evaluation data..\n",
      "\n",
      "Recommendation metrics..\n",
      "     K  Precision@K  Recall@K      F1@K     Hit@K     MRR@K\n",
      "0    5     0.014171  0.004706  0.007065  0.066499  0.017496\n",
      "1   10     0.012663  0.008393  0.010095  0.110385  0.024728\n",
      "2   20     0.008258  0.010210  0.009131  0.136516  0.031672\n",
      "3   50     0.007384  0.021559  0.011000  0.260637  0.038010\n",
      "4  100     0.005635  0.032554  0.009607  0.343049  0.039013\n",
      "5  200     0.005004  0.058533  0.009220  0.485260  0.039220 \n",
      "\n",
      "Overall MRR:  0.030300381130132045\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1360x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# getting ground truth and predictions for validation set\n",
    "print('Getting evaluation data..\\n')\n",
    "gt, pred = get_eval_data(ratings_val)\n",
    "\n",
    "# generating evaluation metrics\n",
    "df_scores = get_recommendation_metrics(gt, pred)\n",
    "print('Recommendation metrics..')\n",
    "print(df_scores,'\\n')\n",
    "\n",
    "# getting overall MRR\n",
    "user_rated_movies = list(gt.values())\n",
    "predictions = list(pred.values())\n",
    "print('Overall MRR: ', mean_reciprocal_rank(user_rated_movies, predictions))\n",
    "\n",
    "# plotting metrics\n",
    "plotting(df_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "951daa5e1959839fcb325fff331f52e72634f7a1be998f6081ed7f433b63f1b3"
  },
  "kernelspec": {
   "display_name": "Python 3.8.11 64-bit ('base': conda)",
   "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.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}