P9_v0.2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "169ace37-c044-44e7-a835-bbff99a0637e",
   "metadata": {},
   "source": [
    "### Import Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "42da6704-2711-45d2-832a-b2d52f2c442c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#globo user data\n",
    "import pandas as pd\n",
    "#article content embedding : np matrix 364047 articles / 250D\n",
    "#embeddings can be used by Neural Networks to represent their content\n",
    "items2vec = pd.read_pickle(r'data/news-portal-user-interactions-by-globocom/articles_embeddings.pickle')\n",
    "#metadata info about 364047 articles\n",
    "items = pd.read_csv('data/news-portal-user-interactions-by-globocom/articles_metadata.csv', delimiter = ',')\n",
    "#all_click\n",
    "for i in range(365):\n",
    "    temp=pd.read_csv('data/news-portal-user-interactions-by-globocom/clicks/clicks/clicks_hour_'+\"%03d\" % i+'.csv', delimiter = ',')\n",
    "    if i==0:\n",
    "        clics=temp\n",
    "    else:\n",
    "        clics=pd.concat([clics, temp])\n",
    "clics=clics.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0182f75d-5dde-497d-9f42-e06f19350947",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cut_data_by_qtime(qtime=0.5):\n",
    "    '''le problème principal est que la liste d articles étaient presque complètes avant la première interaction\n",
    "        en cutant par un quantile du click_timestamp, on diminuer le nombre de clics mais pas le nombre d'articles\n",
    "        et si on cut par un quantile items.created_at_ts, on aura plus d interactions\n",
    "        \n",
    "        dans l ideal il faut cutter les items par un quantile items.created_at_ts\n",
    "                                et les interactions par un quantile click_timestamp\n",
    "                                en virant toutes les interactions avec des items cuttés\n",
    "                                mais on peut renconter un grand saut dans le nombre d interactions'''\n",
    "\n",
    "    cut_click=clics.click_timestamp.quantile(qtime)\n",
    "    #cut_items=items.created_at_ts.quantile(q)\n",
    "    #fusion items et items2vec \"embedding\"\n",
    "    items_=pd.concat([items,pd.DataFrame(items2vec)], axis=1)\n",
    "    #data cut\n",
    "    clics__=clics.loc[clics.click_timestamp<cut_click].copy()\n",
    "    items__=items_.loc[items_.created_at_ts<cut_click].copy()\n",
    "    \n",
    "    #merge clics & items, pour retirer les articles non connus\n",
    "    data=clics__.loc[clics__.click_article_id.isin(set(items__.article_id))].copy()\n",
    "    data.rename(columns={'click_article_id':'article_id'}, inplace = True)\n",
    "    #display(data)\n",
    "    #1 ligne par item interagi pour chaque user\n",
    "    data_map=data[['user_id','article_id']].groupby(['user_id', 'article_id']).size().to_frame().reset_index()\n",
    "    data_map.columns=['user_id','article_id','nb']\n",
    "    #display(data_map)\n",
    "    #extraction item2vec\n",
    "    items2vec_=items__.iloc[:,5:].to_numpy()\n",
    "    #creation des dicos inner_id/raw_id et raw_id/inner_id\n",
    "    dico_inner_raw_iid = dict( (inner_iid,iid) for inner_iid,iid in enumerate(items__.article_id ))\n",
    "    dico_raw_inner_iid = dict( (iid,inner_iid) for inner_iid,iid in enumerate(items__.article_id ))\n",
    "    return data_map, items__, items2vec_, dico_inner_raw_iid, dico_raw_inner_iid\n",
    "\n",
    "data_map,items_df, i2vec, dic_ir, dic_ri=cut_data_by_qtime(qtime=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d483f48d-0a1b-451e-b147-02a8a27f7693",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(27924, 3)\n",
      "(244854, 250)\n",
      "244854\n"
     ]
    }
   ],
   "source": [
    "print(data_map.shape)\n",
    "print(i2vec.shape)\n",
    "print(len(dic_ir))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21808f35-fef2-433a-bf0a-9f2eb4690d16",
   "metadata": {},
   "source": [
    "### Surprise Collaborative Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f97c4f82-8735-4187-be40-8e895276ac8d",
   "metadata": {},
   "source": [
    "#### Approche memory base\n",
    "attention les matrices de similarité uid/uid peuvent etre tres lourdes bloquer le calcul par saturation\n",
    "exemple une matrice 82000/82000 prend deja 50G\n",
    "il faudrait 12000 uid pour ne pas depasser le Giga"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "85b7958a-5c24-4610-a48c-9c43df49ceef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise import Reader, Dataset, KNNWithMeans, KNNWithZScore, SVD, SVDpp, CoClustering\n",
    "from surprise.model_selection import GridSearchCV\n",
    "reader = Reader(rating_scale=(0,5))\n",
    "data = Dataset.load_from_df(data_map, reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e8680d17-f00b-453f-acd9-de3235265859",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "0.05601247255197909\n",
      "{'sim_options': {'name': 'cosine', 'user_based': False}}\n"
     ]
    }
   ],
   "source": [
    "# mesure de similarité: msd et cosine\n",
    "#user based & item_based\n",
    "    #probleme bloquant de memoire: user_based et cosine\n",
    "    #probleme non bloquant de lenteur user_based\n",
    "sim_options = {\n",
    "    \"name\": [\"msd\",\"cosine\"],#default MSD , on peut utiliser cosine\n",
    "    #\"min_support\": [1,2],#, 2, 3, 4, 5], #The minimum number of common items/users\n",
    "    \"user_based\": [True,False]}\n",
    "param_grid = {\"sim_options\": sim_options}\n",
    "gs_KNN_M = GridSearchCV(KNNWithMeans, param_grid, measures=[\"rmse\"], cv=5)\n",
    "gs_KNN_M.fit(data)\n",
    "\n",
    "print(gs_KNN_M.best_score[\"rmse\"])\n",
    "print(gs_KNN_M.best_params[\"rmse\"])\n",
    "#gs_KNN_M.cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b8cf7463-8651-4ee6-8418-def38e11825e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "Computing the cosine similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "0.05286991827164319\n",
      "{'sim_options': {'name': 'msd', 'user_based': True}}\n"
     ]
    }
   ],
   "source": [
    "# mesure de similarité: msd et cosine\n",
    "#user based & item_based\n",
    "    #probleme bloquant de memoire: user_based et cosine\n",
    "    #probleme non bloquant de lenter user_based\n",
    "sim_options = {\n",
    "    \"name\": [\"msd\",\"cosine\"],#default MSD\n",
    "    #\"min_support\": [1,2],#, 2, 3, 4, 5], #The minimum number of common items/users\n",
    "    \"user_based\": [True,False],\n",
    "}\n",
    "param_grid = {\"sim_options\": sim_options}\n",
    "gs_KNN_Z = GridSearchCV(KNNWithZScore, param_grid, measures=[\"rmse\"], cv=5)\n",
    "gs_KNN_Z.fit(data)\n",
    "\n",
    "print(gs_KNN_Z.best_score[\"rmse\"])\n",
    "print(gs_KNN_Z.best_params[\"rmse\"])\n",
    "#gs_KNN_Z.cv_results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f25dad5b-216d-4506-9eb6-e1d0a842d822",
   "metadata": {},
   "source": [
    "#### Approche Model Based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f78955f5-233b-4fe8-99e3-649bd7f1104e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.053651344481960975\n",
      "{'n_epochs': 40, 'lr_all': 0.01, 'reg_all': 0.1}\n"
     ]
    }
   ],
   "source": [
    "param_grid = {\n",
    "    \"n_epochs\": [20,30,40],#[5,10,20,30],#defaut=20\n",
    "    \"lr_all\": [0.002,0.005,0.01],#[0.002, 0.005, 0.007],#defaut=0.005\n",
    "    \"reg_all\": [0.02,0.1],#[0.02, 0.2, 0.4],#regularization term default=0.02\n",
    "}\n",
    "gs_SVD = GridSearchCV(SVD, param_grid, measures=[\"rmse\"], cv=5)\n",
    "gs_SVD.fit(data)\n",
    "\n",
    "print(gs_SVD.best_score[\"rmse\"])\n",
    "print(gs_SVD.best_params[\"rmse\"])\n",
    "#gs_SVD.cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "027f1721-4317-4dda-8c86-1e101453f18b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.04914575909230225\n",
      "{'n_epochs': 30, 'lr_all': 0.007, 'reg_all': 0.1}\n"
     ]
    }
   ],
   "source": [
    "param_grid = {\n",
    "    \"n_epochs\": [20,30,40],#defaut=20\n",
    "    \"lr_all\": [0.007,0.01,0.05],#defaut=0.007\n",
    "    \"reg_all\": [0.02, 0.1],#regularization term default=0.02\n",
    "}\n",
    "gs_SVDpp = GridSearchCV(SVDpp, param_grid, measures=[\"rmse\"], cv=5)\n",
    "gs_SVDpp.fit(data)\n",
    "\n",
    "print(gs_SVDpp.best_score[\"rmse\"])\n",
    "print(gs_SVDpp.best_params[\"rmse\"])\n",
    "#gs_SVDpp.cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3d2e7659-2c29-4aa5-92da-17851398add3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05823718618523051\n",
      "{'n_epochs': 20, 'n_cltr_u': 4, 'n_cltr_i': 3}\n"
     ]
    }
   ],
   "source": [
    "param_grid = {\n",
    "    \"n_epochs\": [20,30,40],#defaut=20\n",
    "    \"n_cltr_u\": [3,4,5],#defaut=3\n",
    "    \"n_cltr_i\": [3,4,5],#regularization term default=3\n",
    "}\n",
    "gs_CoClus = GridSearchCV(CoClustering, param_grid, measures=[\"rmse\"], cv=5)\n",
    "gs_CoClus.fit(data)\n",
    "\n",
    "print(gs_CoClus.best_score[\"rmse\"])\n",
    "print(gs_CoClus.best_params[\"rmse\"])\n",
    "#gs_CoClus.cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "99310f3d-65b3-47c0-adb6-c6ac4fa36a43",
   "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 plt\n",
    "res=[gs_KNN_M.best_score[\"rmse\"],gs_KNN_Z.best_score[\"rmse\"],gs_SVD.best_score[\"rmse\"],\\\n",
    "     gs_SVDpp.best_score[\"rmse\"],gs_CoClus.best_score[\"rmse\"]]\n",
    "res_df = pd.DataFrame(res, index =['KNN_means', 'KNN_zscore', 'SVD', 'SVDpp', 'CoClustering'],\\\n",
    "                      columns =['Surprise collab filtering RMSE'])\n",
    "ax = res_df.plot.bar(rot=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e452e395-dbbb-4e89-b6ac-e01c76aa502d",
   "metadata": {},
   "source": [
    "### Evaluation par Recall@k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "f321ed1f-faff-4266-a73c-48f2c9aee307",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class ModelEvaluator:\n",
    "    def __init__(self,data_map,data_map_train,data_map_test,items_df):\n",
    "        '''constructeur'''\n",
    "        self.full_user_interact=data_map\n",
    "        self.train_user_interact=data_map_train\n",
    "        self.test_user_interact=data_map_test\n",
    "        self.full_items=items_df\n",
    "\n",
    "    def get_random_sample(self, uid, sample_size=100, seed=42):\n",
    "        '''recup d'un set aléatoire d'articles non interagis dans le jeu données complet time cutté\n",
    "            de taille sample_size\n",
    "            pour l'utilisateur uid'''\n",
    "        #on recupere le set non vu par l'utilisateur dans le jeu de données complet time cutté \n",
    "        non_clicked_items = set(self.full_items['article_id']) - set(self.full_user_interact.loc[self.full_user_interact[\"user_id\"]==uid]['article_id'])\n",
    "        #on tire un echantillon alétoire de ce set\n",
    "        random.seed(seed)\n",
    "        non_clicked_items_sample = set(random.sample(non_clicked_items, sample_size))\n",
    "        return non_clicked_items_sample\n",
    "\n",
    "    def _verify_hit_top_n(self, iid, recommended_items, topn):\n",
    "        '''verfie si l'item iid est dans la liste de reco et si il est dans le top n des reco\n",
    "            retourne un duo hit/index\n",
    "            index = place dans la reco de l'iid / -1 pas dans la liste\n",
    "            hit = 1 dans le topn 0 sinon'''\n",
    "        try:\n",
    "            index = next(i for i, c in enumerate(recommended_items) if c == iid)\n",
    "        except:\n",
    "            index = -1\n",
    "        #hit true false si dans le range passé en binaire 0/1\n",
    "        hit = int(index in range(0, topn))\n",
    "        return hit, index\n",
    "\n",
    "    def evaluate_model_for_user(self, model, uid):\n",
    "        '''\n",
    "        EVALUATION DU MODELE PAR UTILISATEUR\n",
    "        \n",
    "        renvoie le pourcentage d'iid clickés de top5/10 dans le test par un uid\n",
    "        pour avoir ce pourcentage , sachant que le nombre d'iid clické peut etre <5 dans le test\n",
    "        on le mix avec 100 iid non clickés alétoires considérés comme irrelevant\n",
    "        '''\n",
    "\n",
    "        #on recupere le SET des articles lus par le user / TEST\n",
    "        uid_test_clicked_items = set(self.test_user_interact.article_id.loc[self.test_user_interact['user_id']==uid]) \n",
    "        #nombre d'articles lus par le user /TEST\n",
    "        uid_test_nb_clicked_items = len(uid_test_clicked_items) \n",
    "        #on recupere la liste reco du modele pour l'uid' (fait dans l'algo de reco: en ignorant les interactions du train du user)\n",
    "        #topn=0 veut dire qu'on sort la liste complete\n",
    "        uid_reco = model.recommend_items(uid,topn=0)#, items_to_ignore=set(self.train_user_interact.loc[self.train_user_interact[\"user_id\"]==uid]['article_id'])) #,topn=5)\n",
    "\n",
    "        hits_at_5_count = 0\n",
    "        hits_at_10_count = 0\n",
    "        #pour article lu par le user dans le TEST\n",
    "        for iid in uid_test_clicked_items:\n",
    "            #set de 100 articles aletoires non lus par le user avec seed constant par iid\n",
    "            uid_non_clicked_items_sample = self.get_random_sample(uid, sample_size=100, seed=iid%(2**32))\n",
    "            #on ajoute l'article courant avec le jeu aleatoire non lus\n",
    "            uid_non_clicked_items_sample_u_test_clicked_iid = uid_non_clicked_items_sample.union(set([iid]))\n",
    "            #filtrage de la reco de 1000 sur 100/101 aleatoire +iid\n",
    "            \n",
    "            \n",
    "            \n",
    "            filt_uid_reco = uid_reco.article_id.loc[uid_reco['article_id'].isin(uid_non_clicked_items_sample_u_test_clicked_iid)]\n",
    "            #on verifie si l'article courant dans le top 5 / top 10 du 100 aleatoires et on incremente le hit count\n",
    "            hit_at_5, index_at_5 = self._verify_hit_top_n(iid, filt_uid_reco.values, 5)\n",
    "            \n",
    "    #print(uid_reco.shape,filt_uid_reco.shape,uid,iid,hit_at_5, index_at_5)\n",
    "            hits_at_5_count += hit_at_5\n",
    "            \n",
    "            hit_at_10, index_at_10 = self._verify_hit_top_n(iid, filt_uid_reco.values, 10)\n",
    "            hits_at_10_count += hit_at_10\n",
    "\n",
    "        #when mixed with a set of non-relevant items\n",
    "        # pourcentage d'articles clickés dans le test dans le top 5/10 d'un sample mix de 100 items aléatoires considérés comme irrelevant à 100%\n",
    "        uid_recall_at_5 = hits_at_5_count / float(uid_test_nb_clicked_items)\n",
    "        uid_recall_at_10 = hits_at_10_count / float(uid_test_nb_clicked_items)\n",
    "\n",
    "        uid_metrics = {'hits@5_count':hits_at_5_count, \n",
    "                        'hits@10_count':hits_at_10_count, \n",
    "                        'interacted_count': uid_test_nb_clicked_items,\n",
    "                        'recall@5': uid_recall_at_5,\n",
    "                        'recall@10': uid_recall_at_10}\n",
    "        return uid_metrics\n",
    "\n",
    "    def evaluate_model(self, model,breaknb):\n",
    "        '''\n",
    "        EVALUATION DU MODELE\n",
    "            top5 global\n",
    "            top10 global\n",
    "        '''\n",
    "        #calcul des stat pour chaque utilisateur du test ET PRESENT DANS LE TRAIN\n",
    "        people_metrics = []\n",
    "        random.seed(42)\n",
    "        #on fait la liste d'uid : on utilise set pour sa propriete d'unicité et ensuite on repasse ne list pour pouvoir shuffuliser\n",
    "        list_uid=list(set(self.test_user_interact.user_id.unique()).intersection(set(self.train_user_interact.user_id.unique())))\n",
    "        random.shuffle(list_uid)\n",
    "        for idx, uid in enumerate(list_uid):\n",
    "            if idx % 100 == 0 and idx > 0:\n",
    "                print('%d users processed' % idx, end='\\r')\n",
    "            person_metrics = self.evaluate_model_for_user(model, uid)  \n",
    "            person_metrics['uid'] = uid\n",
    "            people_metrics.append(person_metrics)\n",
    "            print(idx, end='\\r')\n",
    "            ############\n",
    "            if idx==breaknb:\n",
    "                break\n",
    "            ############\n",
    "        print('%d users processed' % idx)\n",
    "\n",
    "        results = pd.DataFrame(people_metrics).sort_values('interacted_count', ascending=False)\n",
    "        \n",
    "        global_recall_at_5 = results['hits@5_count'].sum() / float(results['interacted_count'].sum())\n",
    "        global_recall_at_10 = results['hits@10_count'].sum() / float(results['interacted_count'].sum())\n",
    "        \n",
    "        global_metrics = {'modelName': model.get_model_name(),\n",
    "                          'recall@5': global_recall_at_5,\n",
    "                          'recall@10': global_recall_at_10}    \n",
    "        return global_metrics, results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "f1323493-fe92-41d7-8472-47507680b5a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 7, 8, 5, 9, 3, 6, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "h={1,2,3,4,5,6,7,8,9}\n",
    "hl=[1,2,3,4,5,6,7,8,9]\n",
    "ht=(1,2,3,4,5,6,7,8,9)\n",
    "hu=list(h)\n",
    "random.seed(42)\n",
    "random.shuffle(hu)\n",
    "print(hu)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "165cffaf-5d5d-42d0-baaa-386de35e954c",
   "metadata": {},
   "source": [
    "### content based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "f5486962-4289-4b94-9f14-8d16c7ee768b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn import preprocessing\n",
    "import scipy\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "class ContentBasedRecommender:\n",
    "    '''le fit calcule les users profiles'''\n",
    "    \n",
    "    MODEL_NAME = 'Content-Based'\n",
    "    \n",
    "\n",
    "    def __init__(self,data_map,i2vec,dic_ri,dic_ir):\n",
    "        '''constructeur'''\n",
    "        #dico inner raw iid\n",
    "        self.dic_ir = dic_ir\n",
    "        #dico raw inner iid\n",
    "        self.dic_ri = dic_ri\n",
    "        self.items_embedding = i2vec\n",
    "        #les train interactions servent à:\n",
    "            #calculer les profils\n",
    "            #ignorer les interactions dans la reco\n",
    "        self.train_user_interact = data_map\n",
    "        \n",
    "    ###############################################################\n",
    "    #profilage des users avec le fit\n",
    "        \n",
    "    def _build_users_profile(self,uid, click_df,emb_matrix,dic_ri):\n",
    "        '''calcul du profil embedding pour un uid\n",
    "        à partir des interactions du train'''\n",
    "        #on recupere le dataframe d'interaction pour l'uid ciblé\n",
    "        click_uid_df = click_df.loc[click_df.user_id==uid]\n",
    "        #on recupere les embeddings des items vus par l'uid\n",
    "        user_item_profiles = np.array([emb_matrix[dic_ri[iid]] for iid in click_uid_df['article_id']])\n",
    "        #on recupere le nombre de click sur les articles par l'uid afin d apporter une ponderation à la moyenne des embedding pour le calcul du profil\n",
    "        user_item_strengths = np.array(click_uid_df['nb']).reshape(-1,1) #-1 veut dire unknow dim\n",
    "        #on pondere la localisation embedding de chaque item par le nombre d'interactions puis on somme afin d'obtenir le profile qui est un barycentre\n",
    "        user_item_strengths_weighted_avg = np.sum(np.multiply(user_item_profiles,user_item_strengths), axis=0) / np.sum(user_item_strengths)\n",
    "        user_profile_norm = preprocessing.normalize(np.reshape(user_item_strengths_weighted_avg,(1,250)))\n",
    "        return user_profile_norm\n",
    "\n",
    "    def _build_users_profiles(self,click_df, emb_matrix,dic_ri): \n",
    "        '''calcul des profils de tous les uid sous forme de dic {uid:profil}\n",
    "        à partir des interactions du train'''\n",
    "        user_profiles = {}\n",
    "        for uid in click_df.user_id.unique():\n",
    "            user_profiles[uid] = self._build_users_profile(uid, click_df, emb_matrix, dic_ri)\n",
    "        return user_profiles\n",
    "    \n",
    "    def fit(self):\n",
    "        '''calcul des profils utilisateurs'''\n",
    "        self.user_profiles=self._build_users_profiles(self.train_user_interact,self.items_embedding,self.dic_ri)\n",
    "        #return self.user_profiles\n",
    "        \n",
    "    ###############################################################\n",
    "    \n",
    "    \n",
    "    def get_model_name(self):\n",
    "        '''renvoie le nom du modèle'''\n",
    "        return self.MODEL_NAME\n",
    "    \n",
    "\n",
    "    def _get_similar_items_to_user_profile(self, uid):#, topn=100000):\n",
    "        '''renvoie une liste d items similaires au profil de l'uid\n",
    "            liste de couples (raw iid, cosine) triés par cosine decroissant'''\n",
    "        #on calcul distances profil uid vs articles : sous forme 2D 1 ligne / nombre iid colonnes dans l'ordre inner du wemb\n",
    "        cosine_similarities = cosine_similarity(self.user_profiles[uid], self.items_embedding)\n",
    "        #on tri par distance: argsort donne les indices par scores croissants /flatten pour passer en 1D\n",
    "        #on recupère un array des inner_iid de taille topn : les plus proches du profil sont à droite\n",
    "        similar_indices = cosine_similarities.argsort().flatten()#[-topn:]\n",
    "                                                        ################################################################################\n",
    "        #on tri : sorted(iterable, key=None, reverse=False)\n",
    "        # l'iterable est une liste de couples (raw_iid, cosine similarites)\n",
    "        #on tri par similarité décroissante\n",
    "        similar_items = [(self.dic_ir[i], cosine_similarities[0,i]) for i in similar_indices[::-1]]\n",
    "        return similar_items\n",
    "    \n",
    "    #methode qui recommande en ignorant les articles deja vus\n",
    "    def recommend_items(self, uid, topn=5):\n",
    "        '''renvoie une liste de reco similaires au profil de l uid\n",
    "            triés par cosine decroissant\n",
    "             sans les interactions du train\n",
    "                sous forme de dataframe'''\n",
    "        #on recupere la liste brute de 1200 reco classés par cosine decroissant\n",
    "        similar_items = self._get_similar_items_to_user_profile(uid)\n",
    "        #on recupere la liste des iid a ignorer car deja vus\n",
    "        #items_to_ignore = self.train_user_interact.loc[self.train_user_interact.user_id==uid,\"article_id\"].tolist()\n",
    "        items_to_ignore = set(self.train_user_interact.loc[self.train_user_interact.user_id==uid].article_id)\n",
    "        #on enleve les deja vus\n",
    "        #similar_items_filtered = list(filter(lambda x: x[0] not in items_to_ignore, similar_items))\n",
    "        recommendations_df = pd.DataFrame(similar_items, columns=['article_id', 'cb_cosine_with_profile'])\n",
    "        reco = recommendations_df.loc[recommendations_df.article_id.isin(items_to_ignore)==False].copy()\n",
    "        if topn>0:\n",
    "            reco=reco.head(topn)\n",
    "        return reco"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd4389e-ff20-4d18-a80f-0c1450291350",
   "metadata": {},
   "source": [
    "#### Collab Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "35b860a7-9821-4f4e-86e5-4987379e0bf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from surprise import Reader, Dataset,SVDpp\n",
    "class CollabFiltRecommender:\n",
    "    \n",
    "    MODEL_NAME = 'Collaborative-Filtering-SVDpp'\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self,data_map):\n",
    "        '''constructeur'''\n",
    "        #les train interactions servent à:\n",
    "            #calculer les profils\n",
    "            #ignorer les interactions dans la reco\n",
    "        self.train_user_interact = data_map\n",
    "        \n",
    "    #methode qui renvoie le nom du modele    \n",
    "    def get_model_name(self):\n",
    "        return self.MODEL_NAME\n",
    "    \n",
    "    #fit du modèle\n",
    "    def fit(self):\n",
    "        'fit du modele SVDpp'\n",
    "        #constructeur du reader\n",
    "        reader = Reader(rating_scale=(0,5))\n",
    "        #lecture du train par surprise\n",
    "        data = Dataset.load_from_df(self.train_user_interact[['user_id','article_id','nb']], reader)\n",
    "        #costruction du trainset surprise \n",
    "        trainset = data.build_full_trainset()\n",
    "        self.algo = SVDpp(n_epochs=20, lr_all=0.007, reg_all=0.1)\n",
    "        self.algo.fit(trainset)\n",
    "\n",
    "    \n",
    "    def recommend_items(self,uid,topn=5):\n",
    "        '''renvoie une liste de prediction pour un uid\n",
    "            le SVD ne peut sortir des prédictions que pour les uid et iid dispo dans le train'''\n",
    "        #prediction fonctionne avec les raws id\n",
    "        #https://towardsdatascience.com/difference-between-apply-and-transform-in-pandas-242e5cf32705\n",
    "        iid_to_ignore=set(self.train_user_interact.loc[self.train_user_interact.user_id==uid].article_id)\n",
    "        items2pred=pd.DataFrame(set(self.train_user_interact.article_id)-iid_to_ignore,columns=['article_id'])\n",
    "        items2pred['pred']=items2pred['article_id'].apply(lambda x:self.algo.predict(uid=uid, iid=x)[3])\n",
    "        #pred['detail']=pred['article_id'].apply(lambda x:cf.predict(uid=uid, iid=x)[4])\n",
    "        if topn==0:\n",
    "            recommendations_df=items2pred.loc[:,['article_id','pred']].sort_values(by='pred', ascending=False)\n",
    "        else:\n",
    "            recommendations_df=items2pred.loc[:,['article_id','pred']].sort_values(by='pred', ascending=False).head(topn)\n",
    "\n",
    "        return recommendations_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c498e0c-60ff-42ea-9582-5c8ee67f5c3b",
   "metadata": {},
   "source": [
    "#### Popularity Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "890d81cc-676e-4374-a57c-8ed127dc7b94",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PopularityFiltRecommender:\n",
    "    \n",
    "    MODEL_NAME = 'Popularity-Filtering'\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self,data_map):\n",
    "        '''constructeur'''\n",
    "        self.train_user_interact = data_map\n",
    "        \n",
    "    #methode qui renvoie le nom du modele    \n",
    "    def get_model_name(self):\n",
    "        return self.MODEL_NAME\n",
    "    \n",
    "    #fit du modèle\n",
    "    def fit(self):\n",
    "        self.raw_reco=self.train_user_interact[['nb','article_id']].groupby(['article_id']).sum().sort_values(by=['nb'],ascending=False).reset_index()\n",
    "\n",
    "    def recommend_items(self,uid,topn=5):\n",
    "        '''renvoie une liste de prediction pour un uid'''\n",
    "        if topn==0:\n",
    "            recommendations_df=self.raw_reco\n",
    "        else:\n",
    "            recommendations_df=self.raw_reco.head(topn)\n",
    "        return recommendations_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa905c9-dea2-4314-ac01-097939760ef0",
   "metadata": {},
   "source": [
    "#### Hybrid Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "5f32beed-ac9b-4191-bed5-4c48b97232b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class HybridRecommender:\n",
    "    \n",
    "    MODEL_NAME = 'Hybrid-Filtering'\n",
    "    \n",
    "    #constructeur\n",
    "    def __init__(self,data_map,i2vec,dic_ri,dic_ir):\n",
    "        '''constructeur'''\n",
    "        self.train_user_interact = data_map\n",
    "        self.dic_ir = dic_ir\n",
    "        self.dic_ri = dic_ri\n",
    "        self.items_embedding = i2vec\n",
    "    \n",
    "    def get_model_name(self):\n",
    "        return self.MODEL_NAME\n",
    "    \n",
    "    #fit du modèle\n",
    "    def fit(self):\n",
    "        '''le fit consiste a fitter les sous modèles'''\n",
    "        self.cf_model = CollabFiltRecommender(self.train_user_interact)\n",
    "        self.cf_model.fit()\n",
    "        self.cb_model = ContentBasedRecommender(self.train_user_interact,self.items_embedding,self.dic_ri,self.dic_ir)\n",
    "        self.cb_model.fit()\n",
    "        self.pf_model = PopularityFiltRecommender(self.train_user_interact)\n",
    "        self.pf_model.fit()\n",
    "        \n",
    "    def recommend_items(self,uid,topn=5):\n",
    "        '''renvoie une liste de prediction pour un uid'''\n",
    "        #si uid pas connu du train: seul le popularity recommander fonctionne dans notre cas\n",
    "        #on pourrait également concevoir un social reco basé sur un social profil, encore faudrait il avoir assez d 'infos'\n",
    "        if uid not in set(self.train_user_interact.user_id):\n",
    "            #parfait quand l'uid n'est pas connu du train, n a pas  d'interactions\n",
    "            reco=self.pf_model.recommend_items(uid,0)\n",
    "        else:\n",
    "                # content based : permet de donner des iid qui n'ont pas d'interactions mais qui étaient disponibles\n",
    "            reco_cb=self.cb_model.recommend_items(uid,0)\n",
    "                # pour la normalisation, le but est de garder les meilleurs, donc les outliers positifs\n",
    "                #il vaut mieux dans ce cas diviser par le max que par une standard deviation \n",
    "                #qui ne rendra pas forcement les outliers similaires entre facteurs pour une pondéaration\n",
    "            #reco_cb['norm_cb']=(reco_cb.cb_cosine_with_profile-reco_cb.cb_cosine_with_profile.median())/(reco_cb.cb_cosine_with_profile.max()-reco_cb.cb_cosine_with_profile.median())\n",
    "            reco_cb['rank_cb']=reco_cb.cb_cosine_with_profile.rank(ascending=False)\n",
    "                # donne de bons resultats mais necessite des uid et des iid qui ont des interactions dans le train\n",
    "            reco_cf=self.cf_model.recommend_items(uid,0)\n",
    "            #reco_cf['norm_cf']=(reco_cf.pred-reco_cf.pred.median())/(reco_cf.pred.max()-reco_cf.pred.median())\n",
    "            reco_cf['rank_cf']=reco_cf.pred.rank(ascending=False)\n",
    "                #comment les pondérer? 80/20 normalisé par exemple?\n",
    "                #en gros la pondération est anecdotique: on privilegie CF et quand on a pas de CF, on met la note de CB\n",
    "            reco = reco_cb.merge(reco_cf,how='outer', on='article_id')\n",
    "                #on fill les norm_cf vides (iid inconnu du train) par norm_cv avant pondération\n",
    "                #on pourait également filler les iid peu interagis afin de favoriser le content dans ce cas la\n",
    "            reco.loc[reco['rank_cf'].isnull(),'rank_cf'] = reco['rank_cb']\n",
    "            reco['rank']=0.99999*reco['rank_cf']+0.00001*reco['rank_cb']\n",
    "            \n",
    "            reco=reco.sort_values(by='rank', ascending=True)\n",
    "\n",
    "\n",
    "        if topn==0:\n",
    "            recommendations_df=reco\n",
    "        else:\n",
    "            recommendations_df=reco.head(topn)\n",
    "            \n",
    "        return recommendations_df.reset_index(drop=True)\n",
    "        #return recommendations_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "73f966a7-3c61-4ec7-a972-5c8a647c4c6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils import shuffle\n",
    "\n",
    "data_map,items_df, i2vec, dic_ir, dic_ri=cut_data_by_qtime(qtime=0.3)\n",
    "\n",
    "data_map_sh=shuffle(data_map,random_state=42)\n",
    "train, test = train_test_split(data_map_sh[['user_id','article_id','nb']],test_size=0.20,shuffle=False)#random_state=42)#,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "f79a83be-fa6d-4009-94a1-b952ee357a1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "pf_model = PopularityFiltRecommender(train)\n",
    "pf_model.fit()\n",
    "#cf_model.recommend_items(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "fc966146-3542-4ba7-9f1d-8b22f55824bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000 users processed\n"
     ]
    }
   ],
   "source": [
    "model_evaluator = ModelEvaluator(data_map_sh,train,test,items_df)\n",
    "global_metrics,results = model_evaluator.evaluate_model(model=pf_model,breaknb=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "32064e74-c56d-43fc-ac07-0ab9c1cca2c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'modelName': 'Popularity-Filtering',\n",
       " 'recall@5': 0.9874357509994289,\n",
       " 'recall@10': 0.989149057681325}"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "dbd23cb6-1e67-4567-8351-ca6cf6564981",
   "metadata": {},
   "outputs": [],
   "source": [
    "cb_model = ContentBasedRecommender(train,i2vec,dic_ri,dic_ir)\n",
    "cb_model.fit()\n",
    "#cb_model.recommend_items(uid=3,topn=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "c611b898-57b6-40e6-af39-327924aeaefe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 users processed\n"
     ]
    }
   ],
   "source": [
    "model_evaluator = ModelEvaluator(data_map_sh,train,test,items_df)\n",
    "global_metrics,results = model_evaluator.evaluate_model(model=cb_model,breaknb=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "33209e70-882e-4c00-9234-788b54bb5b76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'modelName': 'Content-Based',\n",
       " 'recall@5': 0.29878048780487804,\n",
       " 'recall@10': 0.40853658536585363}"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "66a98e8c-dae1-4fcc-ba11-6e96f996beb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf_model = CollabFiltRecommender(train)\n",
    "cf_model.fit()\n",
    "#cf_model.recommend_items(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "fe299e04-143c-4666-8c66-d0e914fbdd40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000 users processed\n"
     ]
    }
   ],
   "source": [
    "model_evaluator = ModelEvaluator(data_map_sh,train,test,items_df)\n",
    "global_metrics,results = model_evaluator.evaluate_model(model=cf_model,breaknb=2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "ca34228b-c603-4a92-a590-0174fc7a00b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'modelName': 'Collaborative-Filtering-SVDpp',\n",
       " 'recall@5': 0.7944031981724728,\n",
       " 'recall@10': 0.9868646487721302}"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "e28146a0-40fe-4979-8d35-7bc8564f45d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "hr_model = HybridRecommender(train,i2vec,dic_ri,dic_ir)\n",
    "hr_model.fit()\n",
    "#cb_model.recommend_items(uid=3,topn=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "id": "437ce568-4788-4eaa-9dd9-751bc7c44ed4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 users processed\n"
     ]
    }
   ],
   "source": [
    "model_evaluator = ModelEvaluator(data_map_sh,train,test,items_df)\n",
    "global_metrics,results = model_evaluator.evaluate_model(model=hr_model,breaknb=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "id": "203e04e1-80c0-4b1b-a89e-45ec38920125",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'modelName': 'Hybrid-Filtering',\n",
       " 'recall@5': 0.2804878048780488,\n",
       " 'recall@10': 0.8902439024390244}"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "id": "95ed6746-029f-4166-8255-88b0dc5f3b36",
   "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>article_id</th>\n",
       "      <th>cb_cosine_with_profile</th>\n",
       "      <th>rank_cb</th>\n",
       "      <th>pred</th>\n",
       "      <th>rank_cf</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>286255</td>\n",
       "      <td>0.826176</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>68851</td>\n",
       "      <td>0.572613</td>\n",
       "      <td>18779.0</td>\n",
       "      <td>2.091679</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.18778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>285728</td>\n",
       "      <td>0.820202</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>237071</td>\n",
       "      <td>0.465695</td>\n",
       "      <td>53805.0</td>\n",
       "      <td>2.001314</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.53803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>284145</td>\n",
       "      <td>0.820047</td>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>313316</td>\n",
       "      <td>0.359395</td>\n",
       "      <td>107765.0</td>\n",
       "      <td>1.211659</td>\n",
       "      <td>49.0</td>\n",
       "      <td>50.07716</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>338553</td>\n",
       "      <td>0.583444</td>\n",
       "      <td>16338.0</td>\n",
       "      <td>1.210435</td>\n",
       "      <td>50.0</td>\n",
       "      <td>50.16288</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>284588</td>\n",
       "      <td>0.789854</td>\n",
       "      <td>51.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>51.0</td>\n",
       "      <td>51.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>214341</td>\n",
       "      <td>0.611811</td>\n",
       "      <td>11001.0</td>\n",
       "      <td>1.209992</td>\n",
       "      <td>51.0</td>\n",
       "      <td>51.10950</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>284969</td>\n",
       "      <td>0.789716</td>\n",
       "      <td>52.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>52.0</td>\n",
       "      <td>52.00000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    article_id  cb_cosine_with_profile   rank_cb      pred  rank_cf      rank\n",
       "0       286255                0.826176       1.0       NaN      1.0   1.00000\n",
       "1        68851                0.572613   18779.0  2.091679      1.0   1.18778\n",
       "2       285728                0.820202       2.0       NaN      2.0   2.00000\n",
       "3       237071                0.465695   53805.0  2.001314      2.0   2.53803\n",
       "4       284145                0.820047       3.0       NaN      3.0   3.00000\n",
       "..         ...                     ...       ...       ...      ...       ...\n",
       "95      313316                0.359395  107765.0  1.211659     49.0  50.07716\n",
       "96      338553                0.583444   16338.0  1.210435     50.0  50.16288\n",
       "97      284588                0.789854      51.0       NaN     51.0  51.00000\n",
       "98      214341                0.611811   11001.0  1.209992     51.0  51.10950\n",
       "99      284969                0.789716      52.0       NaN     52.0  52.00000\n",
       "\n",
       "[100 rows x 6 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>article_id</th>\n",
       "      <th>cb_cosine_with_profile</th>\n",
       "      <th>rank_cb</th>\n",
       "      <th>pred</th>\n",
       "      <th>rank_cf</th>\n",
       "      <th>rank</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>68851</td>\n",
       "      <td>0.572613</td>\n",
       "      <td>18779.0</td>\n",
       "      <td>2.091679</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.18778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>237071</td>\n",
       "      <td>0.465695</td>\n",
       "      <td>53805.0</td>\n",
       "      <td>2.001314</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.53803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>43032</td>\n",
       "      <td>0.340698</td>\n",
       "      <td>118564.0</td>\n",
       "      <td>1.874616</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.18561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>38823</td>\n",
       "      <td>0.296158</td>\n",
       "      <td>145375.0</td>\n",
       "      <td>1.821510</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.45371</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>313513</td>\n",
       "      <td>0.401510</td>\n",
       "      <td>84659.0</td>\n",
       "      <td>1.545973</td>\n",
       "      <td>5.0</td>\n",
       "      <td>5.84654</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>185</th>\n",
       "      <td>65567</td>\n",
       "      <td>0.542987</td>\n",
       "      <td>26488.0</td>\n",
       "      <td>1.184170</td>\n",
       "      <td>97.0</td>\n",
       "      <td>97.26391</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>187</th>\n",
       "      <td>142279</td>\n",
       "      <td>0.110403</td>\n",
       "      <td>231804.0</td>\n",
       "      <td>1.184377</td>\n",
       "      <td>96.0</td>\n",
       "      <td>98.31708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>189</th>\n",
       "      <td>264904</td>\n",
       "      <td>0.199357</td>\n",
       "      <td>199206.0</td>\n",
       "      <td>1.182505</td>\n",
       "      <td>98.0</td>\n",
       "      <td>99.99108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>192</th>\n",
       "      <td>248489</td>\n",
       "      <td>0.181253</td>\n",
       "      <td>207557.0</td>\n",
       "      <td>1.181773</td>\n",
       "      <td>99.0</td>\n",
       "      <td>101.07458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>193</th>\n",
       "      <td>256636</td>\n",
       "      <td>0.201620</td>\n",
       "      <td>198070.0</td>\n",
       "      <td>1.181681</td>\n",
       "      <td>100.0</td>\n",
       "      <td>101.97970</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     article_id  cb_cosine_with_profile   rank_cb      pred  rank_cf  \\\n",
       "1         68851                0.572613   18779.0  2.091679      1.0   \n",
       "3        237071                0.465695   53805.0  2.001314      2.0   \n",
       "6         43032                0.340698  118564.0  1.874616      3.0   \n",
       "8         38823                0.296158  145375.0  1.821510      4.0   \n",
       "9        313513                0.401510   84659.0  1.545973      5.0   \n",
       "..          ...                     ...       ...       ...      ...   \n",
       "185       65567                0.542987   26488.0  1.184170     97.0   \n",
       "187      142279                0.110403  231804.0  1.184377     96.0   \n",
       "189      264904                0.199357  199206.0  1.182505     98.0   \n",
       "192      248489                0.181253  207557.0  1.181773     99.0   \n",
       "193      256636                0.201620  198070.0  1.181681    100.0   \n",
       "\n",
       "          rank  \n",
       "1      1.18778  \n",
       "3      2.53803  \n",
       "6      4.18561  \n",
       "8      5.45371  \n",
       "9      5.84654  \n",
       "..         ...  \n",
       "185   97.26391  \n",
       "187   98.31708  \n",
       "189   99.99108  \n",
       "192  101.07458  \n",
       "193  101.97970  \n",
       "\n",
       "[100 rows x 6 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hz=hr_model.recommend_items(uid=5,topn=0)\n",
    "display(hz.head(100))\n",
    "display(hz.loc[hz.pred.isnull()==False].head(100))#.sort_values(by=\"norm_cf\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dcb404c-c003-41a9-9473-918f866e5702",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "env"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}