Main-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from collections import defaultdict\n",
    "import csv\n",
    "import nltk\n",
    "from matplotlib import pyplot as plt\n",
    "import os\n",
    "import re\n",
    "import warnings\n",
    "import random\n",
    "warnings.filterwarnings('ignore')\n",
    "from collections import Counter,defaultdict\n",
    "from nltk import word_tokenize\n",
    "from math import log\n",
    "import string\n",
    "import pickle\n",
    "from math import log\n",
    "import gensim\n",
    "from gensim import corpora\n",
    "from gensim import models\n",
    "from string import digits\n",
    "from collections import defaultdict\n",
    "from scipy.spatial.distance import cosine\n",
    "import ast\n",
    "cwd = os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "osname = os.name\n",
    "if osname =='Windows':\n",
    "    sym = \"//\"\n",
    "else:\n",
    "    sym = \"/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_path=cwd+sym+'nips_reviewer_data'+sym+'reviewers.txt'\n",
    "review_df=pd.read_csv(r_path,sep='\\t',header=None)\n",
    "review_df.columns=['sno','name']\n",
    "review_lt=list(review_df.name)\n",
    "review_sno={val:ind for ind,val in enumerate(review_lt)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Necessary files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "path1=cwd+sym+'Saved_Items'+sym\n",
    "with open(path1+'dictionary.pkl','rb') as f:\n",
    "    dictionary=pickle.load(f)\n",
    "with open(path1+'tfidf.pkl','rb') as f:\n",
    "    tfidf=pickle.load(f)\n",
    "with open(path1+'ldaModel250','rb') as f:\n",
    "    lda_model=pickle.load(f)\n",
    "with open(path1+'cocit.pkl','rb') as f:\n",
    "    cocit_mat=pickle.load(f)\n",
    "with open(path1+'bibcoupling.pkl','rb') as f:\n",
    "    bc_mat=pickle.load(f)\n",
    "with open(path1+'distance.pkl','rb') as f:\n",
    "    dist=pickle.load(f)\n",
    "with open(path1+'paper_vec2.pkl','rb') as f:\n",
    "    paper_vec2=pickle.load(f)\n",
    "with open(path1+'paper_id.pkl','rb') as f:\n",
    "    paper_id=pickle.load(f)\n",
    "with open(path1+'reviewer_vec.pkl','rb') as f:\n",
    "    reviewer_vec=pickle.load(f)\n",
    "with open(path1+'topic_community.pkl','rb') as f:\n",
    "    topic_comm=pickle.load(f)\n",
    "with open(path1+'paper_auth.pkl','rb') as f:\n",
    "    paper_auth=pickle.load(f)\n",
    "with open(path1+'reviewer_matrix.pkl','rb') as f:\n",
    "    reviewer_matrix=pickle.load(f)\n",
    "with open(path1+'reviewer_vec_bow.pkl','rb') as f:\n",
    "    reviewer_vec_bow=pickle.load(f)\n",
    "reviewer_detail=pd.read_pickle(path1+'auth_detail.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## New Paper's Title and Abstract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "title='Learning from Multiple Sources'\n",
    "abstract='''\n",
    "Categorization is a central activity of human cognition. When an individual is asked to categorize a sequence of items, context effects arise: categorization of one item influences category decisions for subsequent items. Specifically, when experimental subjects are shown an exemplar of some target category, the category prototype appears to be pulled toward the exemplar, and the prototypes of all nontarget categories appear to be pushed away. These push and pull effects diminish with experience, and likely reflect long-term learning of category boundaries. We propose and evaluate four principled probabilistic (Bayesian) accounts of context effects in categorization. In all four accounts, the probability of an exemplar given a category is encoded as a Gaussian density in feature space, and categorization involves computing category posteriors given an exemplar. The models differ in how the uncertainty distribution of category prototypes is represented (localist or distributed), and how it is updated following each experience (using a maximum likelihood gradient ascent, or a Kalman filter update). We find that the distributed maximum-likelihood model can explain the key experimental phenomena. Further, the model predicts other phenomena that were confirmed via reanalysis of the experimental data. Categorization is a central activity of human cognition. We continually make decisions about characteristics of objects and individuals: Is the fruit ripe? Does your friend seem unhappy? Is your car tire flat? Should this manuscript be accepted for publication in NIPS? When an individual is asked to categorize a sequence of items, context effects arise: categorization of one item influences category decisions for subsequent items. Intuitive naturalistic scenarios in which context effects occur are easy to imagine. For example, if one lifts a medium-weight object after lifting a light-weight or heavy-weight object, the medium weight feels heavier following the light weight than following the heavy weight. Although the object-contrast effect might be due to fatigue of sensory-motor systems, many context effects in categorization are purely cognitive and cannot easily be attributed to neural habituation. For example, if you are reviewing a set of conference papers, and the first three in the set are dreadful, then even a mediocre paper seems like it might be above threshold for acceptance. Another example of a category boundary shift due to context is the following. Suppose you move from San Diego to Pittsburgh and notice that your neighbors repeatedly describe muggy, somewhat overcast days as Ólovely.Ó Eventually, your notion of what constitutes a lovely day accommodates to your new surroundings. As we describe shortly, experimental studies have shown a fundamental link between context effects in categorization and long-term learning of category boundaries. We believe that context effects can be viewed as a reflection of a trial-to-trial learning, and the cumulative effect of these trial-to-trial modulations corresponds to what we classically consider to be category learning. Consequently, any compelling model of category learning should also be capable of explaining context effects. stimulus dimension ABCD example Figure 1: Schematic depiction of sequential effects in categorization \n",
    "'''\n",
    "text=title+abstract"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PreProcessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'groot'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.corpus import stopwords \n",
    "from nltk.stem import PorterStemmer\n",
    "st = set(stopwords.words('english'))\n",
    "from nltk.stem import WordNetLemmatizer \n",
    "import re\n",
    "\n",
    "def cleantext(text):\n",
    "    \n",
    "    remove_digits = str.maketrans('', '', digits)\n",
    "    text = text.translate(remove_digits)\n",
    "    \n",
    "    # remove punctuation\n",
    "    table = str.maketrans(string.punctuation, ' '*len(string.punctuation))\n",
    "    strip = text.translate(table)\n",
    "    \n",
    "    \n",
    "    # Tokenizer\n",
    "    tokens = word_tokenize(strip)\n",
    "    \n",
    "    # Convert into lower case \n",
    "    proc_text = [w.lower() for w in tokens]\n",
    "    \n",
    "    # Remove stopwords\n",
    "    proc_text = [word for word in proc_text if word not in st]\n",
    "    \n",
    "    \n",
    "    #Storing only Lemmmatized words\n",
    "    lemmatizer=WordNetLemmatizer()\n",
    "    lemma_text=[lemmatizer.lemmatize(word) for word in proc_text]\n",
    "\n",
    "    return \" \".join(lemma_text)\n",
    "\n",
    "\n",
    "t = \"i am groot2'7\"    \n",
    "cleantext(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_column_slice(array_or_dataframe,coloumn):\n",
    "    return np.asarray(array_or_dataframe)[:, coloumn]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_topics=250"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Consolidated Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def topic_level(text):\n",
    "    # Loading saved Lda model,dictionary,tfidf vectorizer\n",
    "    \n",
    "    clean_text=list(word_tokenize(cleantext(text))) \n",
    "    bow_text=dictionary.doc2bow(clean_text)\n",
    "    tfidf_text=tfidf[bow_text]\n",
    "    topic=lda_model[tfidf_text]\n",
    "\n",
    "    topic_vec=np.zeros(num_topics)\n",
    "    for ind,wt in topic:\n",
    "        topic_vec[ind]=wt\n",
    "    \n",
    "    # Topic of interest and community\n",
    "    \n",
    "    no_top_topic=5\n",
    "    toi=[]#topic of interest\n",
    "    if len(topic)<no_top_topic:\n",
    "        for ind,wt in topic:\n",
    "            toi.append(ind)\n",
    "    else:\n",
    "        topic.sort(key=lambda x:x[1],reverse=True)\n",
    "        for i in range(no_top_topic):\n",
    "            toi.append(topic[i][0])\n",
    "\n",
    "    \n",
    "    toi_comm=[topic_comm[i] for i in toi]\n",
    "    toi_comm=set(toi_comm)\n",
    "    topic_rest=[]\n",
    "    for index,comm_no in enumerate(topic_comm):\n",
    "        if comm_no in toi_comm and not index in toi:\n",
    "            topic_rest.append(index)\n",
    "    \n",
    "    return topic_vec,toi,topic_rest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def paper_level(toi,topic_rest):\n",
    "    poi=[]#papers having maximuim content of toi\n",
    "    paper_vec_lt=list(paper_vec2.values())\n",
    "    for i in toi:\n",
    "        samp=get_column_slice(paper_vec_lt,i)\n",
    "        ind=np.argmax(np.array(samp))\n",
    "        poi.append(ind)\n",
    "    puc=[]#papers under consideration\n",
    "    for i in topic_rest:\n",
    "        topic_paper=get_column_slice(paper_vec_lt,i)\n",
    "        n1=len(np.where(topic_paper>0)[0])\n",
    "        thres=sum(topic_paper)/n1\n",
    "        ind_list=np.where(topic_paper>thres)[0]\n",
    "        for ele in ind_list:\n",
    "            puc.append(ele)\n",
    "    puc=list(set(puc))\n",
    "    \n",
    "    paper_scr=[]\n",
    "    for i in puc:\n",
    "        num=bc_mat[i]+cocit_mat[i]\n",
    "        den=min([dist[i][j] for j in poi])\n",
    "        if den==0:\n",
    "            scr=float('inf')\n",
    "        else:\n",
    "            scr=num/den\n",
    "        paper_scr.append((scr,i))\n",
    "    \n",
    "    scr=[scr for scr,ind in paper_scr]\n",
    "    val=np.percentile(scr,75)# taking into acccount only top 25% entries\n",
    "    potential_paper=[]\n",
    "    for score,ind in paper_scr:\n",
    "        if score>val:\n",
    "            potential_paper.append(ind)\n",
    "    \n",
    "    \n",
    "    return poi,potential_paper\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reviewer_pred(poi,potential_paper,topic_vec,text):\n",
    "    roi=[]\n",
    "    ct_roi=[]\n",
    "    for i in poi:\n",
    "        roi=roi+paper_auth[i]\n",
    "    rest_reviewer=[]\n",
    "    for i in potential_paper:\n",
    "        if not i in roi:\n",
    "            rest_reviewer=rest_reviewer+paper_auth[i]\n",
    "    \n",
    "    \n",
    "    npaper=list(reviewer_detail['pc'])\n",
    "    citn=list(reviewer_detail['cn'])\n",
    "    \n",
    "    clean_text=list(word_tokenize(cleantext(text))) \n",
    "    bow_text=dictionary.doc2bow(clean_text)\n",
    "    tfidf_text=tfidf[bow_text]\n",
    "    n=len(dictionary)\n",
    "\n",
    "    bow_vec=np.zeros(n, dtype = float)\n",
    "    for ind,wt in tfidf_text:\n",
    "        bow_vec[ind]=wt    \n",
    "    \n",
    "    dec_scr=[]\n",
    "    for i in roi:\n",
    "        sim=1-cosine(reviewer_vec[i],topic_vec)\n",
    "        bow_scr=1-cosine(reviewer_vec_bow[i],bow_vec)\n",
    "        if np.isnan(sim):\n",
    "            sim=0\n",
    "        if np.isnan(bow_scr):\n",
    "            bow_scr=0\n",
    "        #val=0.1*npaper[i]/max(npaper)+0.1*citn[i]/max(citn)+0.8*sim\n",
    "        val=0.6*sim+0.4*bow_scr\n",
    "        #val2=npaper[i]/max(npaper)+citn[i]/max(citn)\n",
    "        dec_scr.append((val,i))\n",
    "    dec_scr.sort(reverse=True)\n",
    "    start_node=dec_scr[0][1]\n",
    "    \n",
    "    n=len(review_lt)\n",
    "    total_node=set([i for i in range(n)])\n",
    "    invalid_node=total_node-set(roi)-set(rest_reviewer)\n",
    "    \n",
    "    custom_matrix=[]\n",
    "    for i in range(n):\n",
    "        temp=[]\n",
    "        for j in range(n):\n",
    "            temp.append(reviewer_matrix[i][j])\n",
    "        custom_matrix.append(np.array(temp))\n",
    "    for node in invalid_node:\n",
    "        for i in range(n):\n",
    "            custom_matrix[node][i]=0\n",
    "            custom_matrix[i][node]=0\n",
    "    col_sum=[sum(x) for x in zip(*custom_matrix)]\n",
    "\n",
    "    transition_prob=[]\n",
    "    for i in range(n):\n",
    "        op=[]\n",
    "        for j in range(n):\n",
    "            if col_sum[j]:\n",
    "                val=custom_matrix[i][j]/col_sum[j]\n",
    "            else:\n",
    "                val=0\n",
    "            op.append(val)\n",
    "        transition_prob.append(op)\n",
    "        \n",
    "    ini_state=[0]*n\n",
    "    ini_state[start_node]=1\n",
    "    len_op=10#No of items to be shown as output\n",
    "    new_state=ini_state\n",
    "    for i in range(len_op):\n",
    "        new_state=np.dot(0.85,np.dot(transition_prob,new_state))+np.dot(0.15,ini_state)\n",
    "        \n",
    "    op=new_state.argsort()[-10:][::-1]\n",
    "    #op=new_state.argsort()[::-1]\n",
    "    res=[ele+1 for ele in op]\n",
    "    \n",
    "    return res\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(text):\n",
    "    topic_vec,toi,topic_rest=topic_level(text)\n",
    "    poi,potential_paper=paper_level(toi,topic_rest)\n",
    "    pred=reviewer_pred(poi,potential_paper,topic_vec,text)\n",
    "    \n",
    "    return pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "path=path1+'Testing'+sym+'trec_judgments.txt'\n",
    "ordinal=[]\n",
    "value=[]\n",
    "judge={}\n",
    "with open(path,'r',encoding=\"utf8\")as f:\n",
    "    for line in f:\n",
    "        ordinal=list(line.split('\\t'))\n",
    "        value=[int(ordinal[2]),int(ordinal[3][:-1])]\n",
    "        if int(ordinal[0][4:]) in judge:\n",
    "            judge[int(ordinal[0][4:])].append(value)\n",
    "        else :\n",
    "            judge[int(ordinal[0][4:])]=[value]\n",
    "            \n",
    "path=path1+'Testing'+sym+'trec_judgments_additional.txt'\n",
    "with open(path,'r',encoding=\"utf8\")as f:\n",
    "    for line in f:\n",
    "        ordinal=list(line.split('\\t'))\n",
    "        value=[int(ordinal[2]),int(ordinal[3][:-1])]\n",
    "        if int(ordinal[0]) in judge:\n",
    "            judge[int(ordinal[0])].append(value)\n",
    "        else :\n",
    "            judge[int(ordinal[0])]=[value]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def precision_k(res,gnd_tht,k,paper_no):\n",
    "    actual=gnd_tht[paper_no]\n",
    "    actual_auth=[i[0] for i in actual]\n",
    "    rating=[i[1] for i in actual]\n",
    "    n=len(actual)\n",
    "    soft_p=0\n",
    "    for i in range(k):\n",
    "        pred=res[i]\n",
    "        for j in range(n):\n",
    "            if actual_auth[j]==pred:\n",
    "                if rating[j]==3:\n",
    "                    soft_p+=1\n",
    "                elif rating[j]==2:\n",
    "                    soft_p+=0.67\n",
    "                elif rating[j]==1:\n",
    "                    soft_p+=0.33\n",
    "                else:\n",
    "                    break\n",
    "    soft_p=soft_p/k\n",
    "    return soft_p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_abs=pd.read_pickle('test_abs')\n",
    "n=len(test_abs)\n",
    "ctr=0\n",
    "avg_precision=[0]*11\n",
    "valid_file=list(judge.keys())\n",
    "for i in range(n):\n",
    "    if i in valid_file:        \n",
    "        res=predict(test_abs['abstract'].iloc[i])\n",
    "        #print(res)\n",
    "        for k in range(1,11):\n",
    "            avg_precision[k]+=precision_k(res,judge,k,i)\n",
    "        ctr+=1\n",
    "avg_precision=[ele/ctr for ele in avg_precision]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.17647058823529413,\n",
       " 0.3283823529411764,\n",
       " 0.2777450980392158,\n",
       " 0.2425735294117646,\n",
       " 0.22541176470588237,\n",
       " 0.22039215686274508,\n",
       " 0.22680672268907573,\n",
       " 0.2180882352941176,\n",
       " 0.20908496732026138,\n",
       " 0.20382352941176468]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_precision[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gndtht_stats(res,gnd_tht,paper_no):\n",
    "    actual=gnd_tht[paper_no]\n",
    "    actual_auth=[i[0] for i in actual]\n",
    "    rating=[i[1] for i in actual]\n",
    "    ctr_3=0\n",
    "    ctr_2=0\n",
    "    ctr_1=0\n",
    "    ctr_0=0\n",
    "    ctr_not=0    \n",
    "    for ele in res:\n",
    "        if ele in actual_auth:\n",
    "            ind=actual_auth.index(ele)\n",
    "            if rating[ind]==3:\n",
    "                ctr_3+=1\n",
    "            elif rating[ind]==2:\n",
    "                ctr_2+=1\n",
    "            elif rating[ind]==1:\n",
    "                ctr_1+=1\n",
    "            else:\n",
    "                ctr_0+=1\n",
    "        else:\n",
    "            ctr_not+=1\n",
    "    return ctr_3,ctr_2,ctr_1,ctr_0,ctr_not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_abs=pd.read_pickle('test_abs')\n",
    "n=len(test_abs)\n",
    "ctr=0\n",
    "avg_precision=[0]*11\n",
    "valid_file=list(judge.keys())\n",
    "op=[]\n",
    "for i in range(n):\n",
    "    if i in valid_file:        \n",
    "        res=predict(test_abs['abstract'].iloc[i])\n",
    "        #print(res)\n",
    "        res1=gndtht_stats(res,judge,i)\n",
    "        op.append([i,res1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File Id: 0\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 3\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 1\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 5\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 3\n",
      "######################################\n",
      "File Id: 2\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 3\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 7\n",
      "######################################\n",
      "File Id: 4\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 0\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 7\n",
      "######################################\n",
      "File Id: 5\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 10\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 11\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 13\n",
      "No of judgement with rel 3: 4\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 0\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 14\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 0\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 7\n",
      "######################################\n",
      "File Id: 16\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 3\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 17\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 18\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 3\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 22\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 26\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 3\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 29\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 34\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 4\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 35\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 36\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 9\n",
      "######################################\n",
      "File Id: 40\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 45\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 3\n",
      "No of judgement with rel 1: 0\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 52\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 56\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 1\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 63\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 3\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 79\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 83\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 8\n",
      "######################################\n",
      "File Id: 88\n",
      "No of judgement with rel 3: 0\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 2\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n",
      "File Id: 93\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 0\n",
      "No of judgement with rel 0: 4\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 103\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 2\n",
      "No of judgement with rel 1: 3\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 3\n",
      "######################################\n",
      "File Id: 128\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 8\n",
      "######################################\n",
      "File Id: 139\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 2\n",
      "No of judgement with rel 0: 4\n",
      "No of judgement not in ground thruth: 2\n",
      "######################################\n",
      "File Id: 144\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 3\n",
      "No of judgement not in ground thruth: 4\n",
      "######################################\n",
      "File Id: 145\n",
      "No of judgement with rel 3: 1\n",
      "No of judgement with rel 2: 0\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 3\n",
      "No of judgement not in ground thruth: 5\n",
      "######################################\n",
      "File Id: 147\n",
      "No of judgement with rel 3: 2\n",
      "No of judgement with rel 2: 1\n",
      "No of judgement with rel 1: 1\n",
      "No of judgement with rel 0: 0\n",
      "No of judgement not in ground thruth: 6\n",
      "######################################\n"
     ]
    }
   ],
   "source": [
    "for entry in op:\n",
    "    file_id=entry[0]\n",
    "    stats=entry[1]\n",
    "    label=['No of judgement with rel 3:','No of judgement with rel 2:','No of judgement with rel 1:','No of judgement with rel 0:','No of judgement not in ground thruth:']\n",
    "    print('File Id:',file_id)\n",
    "    for i in range(5):\n",
    "        print(label[i],stats[i])\n",
    "    print('######################################')\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experimental"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading saved Lda model,dictionary,tfidf vectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_text=list(word_tokenize(cleantext(text))) \n",
    "bow_text=dictionary.doc2bow(clean_text)\n",
    "tfidf_text=tfidf[bow_text]\n",
    "topic=lda_model[tfidf_text]\n",
    "\n",
    "topic_vec=np.zeros(250)\n",
    "for ind,wt in topic:\n",
    "    topic_vec[ind]=wt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(17, 0.0317923164109665),\n",
       " (21, 0.03792223827970085),\n",
       " (24, 0.013261321728855833),\n",
       " (50, 0.05400130781344851),\n",
       " (68, 0.011835838059180436),\n",
       " (84, 0.03094422992582379),\n",
       " (94, 0.012670738633399261),\n",
       " (99, 0.018816494188027052),\n",
       " (114, 0.09314606143090694),\n",
       " (132, 0.03955064441908725),\n",
       " (173, 0.01475569042495382),\n",
       " (195, 0.01132398148568866),\n",
       " (220, 0.06953647026883676),\n",
       " (221, 0.17622761068548076),\n",
       " (244, 0.01045548240124097)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "topic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Topic of interest and community"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "no_top_topic=3\n",
    "toi=[]#topic of interest\n",
    "if len(topic)<no_top_topic:\n",
    "    for ind,wt in topic:\n",
    "        toi.append(ind)\n",
    "else:\n",
    "    topic.sort(key=lambda x:x[1],reverse=True)\n",
    "    for i in range(no_top_topic):\n",
    "        toi.append(topic[i][0])\n",
    "        \n",
    "    \n",
    "toi_comm=[topic_comm[i] for i in toi]\n",
    "toi_comm=set(toi_comm)\n",
    "topic_rest=[]\n",
    "for index,comm_no in enumerate(topic_comm):\n",
    "    if comm_no in toi_comm and not index in toi:\n",
    "        topic_rest.append(index)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toi_comm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "241"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(topic_rest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[221, 114, 84]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paper Level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "poi=[]#papers having maximuim content of toi\n",
    "paper_vec_lt=list(paper_vec2.values())\n",
    "for i in toi:\n",
    "    samp=get_column_slice(paper_vec_lt,i)\n",
    "    ind=np.argmax(np.array(samp))\n",
    "    poi.append(ind)\n",
    "puc=[]#papers under consideration\n",
    "for i in topic_rest:\n",
    "    topic_paper=get_column_slice(paper_vec_lt,i)\n",
    "    n1=len(np.where(topic_paper>0)[0])\n",
    "    thres=sum(topic_paper)/n1\n",
    "    ind_list=np.where(topic_paper>thres)[0]\n",
    "    for ele in ind_list:\n",
    "        puc.append(ele)\n",
    "puc=list(set(puc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9626, 3859, 5892]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_scr=[]\n",
    "for i in puc:\n",
    "    num=bc_mat[i]+cocit_mat[i]\n",
    "    den=min([dist[i][j] for j in poi])\n",
    "    scr=num/den\n",
    "    paper_scr.append((scr,i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "scr=[scr for scr,ind in paper_scr]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "val=np.percentile(scr,90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "potential_paper=[]\n",
    "for score,ind in paper_scr:\n",
    "    if score>val:\n",
    "        potential_paper.append(ind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1205"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(potential_paper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reviewer Identification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "roi=[]\n",
    "ct_roi=[]\n",
    "for i in poi:\n",
    "    roi=roi+paper_auth[i]\n",
    "rest_reviewer=[]\n",
    "for i in potential_paper:\n",
    "    if not i in roi:\n",
    "        rest_reviewer=rest_reviewer+paper_auth[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[212, 238, 91]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "rest_reviewer=list(set(rest_reviewer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "212"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(rest_reviewer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start Node selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "reviewer_detail=pd.read_pickle(path1+'auth_detail.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "npaper=list(reviewer_detail['pc'])\n",
    "citn=list(reviewer_detail['cn'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "dec_scr=[]\n",
    "for i in roi:\n",
    "    sim=1-cosine(reviewer_vec[i],topic_vec)\n",
    "    if np.isnan(sim):\n",
    "        sim=0\n",
    "    val=0.15*npaper[i]/max(npaper)+0.15*citn[i]/max(citn)+0.7*sim\n",
    "    dec_scr.append((val,i))\n",
    "dec_scr.sort(reverse=True)\n",
    "start_node=dec_scr[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "91"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start_node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Walk with Restart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(path1+'reviewer_matrix.pkl','rb') as f:\n",
    "    reviewer_matrix=pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=len(review_lt)\n",
    "total_node=set([i for i in range(n)])\n",
    "invalid_node=total_node-set(roi)-set(rest_reviewer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_matrix=reviewer_matrix[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "for node in invalid_node:\n",
    "    for i in range(n):\n",
    "        custom_matrix[node][i]=0\n",
    "        custom_matrix[i][node]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_sum=custom_matrix.sum(axis=1)\n",
    "transition_prob=[]\n",
    "for i in range(n):\n",
    "    op=[]\n",
    "    for j in range(n):\n",
    "        if col_sum[j]:\n",
    "            val=custom_matrix[i][j]/col_sum[j]\n",
    "        else:\n",
    "            val=0\n",
    "        op.append(val)\n",
    "    transition_prob.append(op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "val=[]\n",
    "for j in range(n):\n",
    "    temp=0\n",
    "    for i in range(n):\n",
    "        temp+=transition_prob[i][j]\n",
    "    val.append(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "ini_state=[0]*n\n",
    "ini_state[start_node]=1\n",
    "len_op=10#No of items to be shown as output\n",
    "new_state=ini_state\n",
    "for i in range(10):\n",
    "    new_state=np.dot(0.7,np.dot(transition_prob,new_state))+np.dot(0.3,ini_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "211"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.count_nonzero(new_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "op=new_state.argsort()[::-1][:30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "op_lt=[]\n",
    "ctr=0\n",
    "for i in op:\n",
    "    if not i in invalid_node:\n",
    "        op_lt.append(i)\n",
    "        ctr+=1\n",
    "    if ctr==10:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[91, 5, 8, 163, 45, 161, 107, 233, 147, 324]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op_lt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "samp_judge=judge[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "samp_judge_review=[sno for sno,rat in samp_judge]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'topic_level' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-a960cbe91a7c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtest_abs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_pickle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test_abs'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mop_lt\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_abs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'abstract'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mop_lt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msamp_judge_review\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0msim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'-inf'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-49-73d608dbd497>\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(text)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mtopic_vec\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtoi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtopic_rest\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtopic_level\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mpoi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpotential_paper\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpaper_level\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtoi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtopic_rest\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mpred\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreviewer_pred\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpotential_paper\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtopic_vec\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'topic_level' is not defined"
     ]
    }
   ],
   "source": [
    "test_abs=pd.read_pickle('test_abs')\n",
    "op_lt=predict(test_abs['abstract'].iloc[0])\n",
    "for i in op_lt:    \n",
    "    if not i in samp_judge_review:\n",
    "        sim=float('-inf')\n",
    "        rat=0\n",
    "        for ind,j in enumerate(samp_judge_review):\n",
    "            v1=1-cosine(reviewer_vec[i-1],reviewer_vec[j-1])\n",
    "            if v1>sim:\n",
    "                sim=v1\n",
    "                rat=samp_judge[ind][1]\n",
    "        samp_judge.append([i,rat])\n",
    "        print([i,rat])\n",
    "        print('YEAH')\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {},
   "outputs": [],
   "source": [
    "def precision_k(res,gnd_tht,k,paper_no):\n",
    "    actual=gnd_tht[paper_no]\n",
    "    actual_auth=[i[0] for i in actual]\n",
    "    rating=[i[1] for i in actual]\n",
    "    n=len(actual)\n",
    "    soft_p=0\n",
    "    #print(actual)\n",
    "    for i in range(k):\n",
    "        pred=res[i]\n",
    "        for j in range(n):\n",
    "            if actual_auth[j]==pred:\n",
    "                if rating[j]==3:\n",
    "                    soft_p+=1\n",
    "                elif rating[j]==2:\n",
    "                    soft_p+=0.67\n",
    "                elif rating[j]==1:\n",
    "                    soft_p+=0.33\n",
    "                break\n",
    "    soft_p=soft_p/k\n",
    "    return soft_p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_precision=[0]*11\n",
    "#print(res)\n",
    "for k in range(1,11):\n",
    "    avg_precision[k]=precision_k1(res,samp_judge,k,i)\n",
    "ctr=1\n",
    "avg_precision=[ele/ctr for ele in avg_precision]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_precision=[0]*11\n",
    "res=predict(test_abs['abstract'].iloc[0])\n",
    "#print(res)\n",
    "for k in range(1,11):\n",
    "    avg_precision[k]=precision_k(res,judge,k,0)\n",
    "ctr=1\n",
    "avg_precision=[ele/ctr for ele in avg_precision]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.33,\n",
       " 0.165,\n",
       " 0.44333333333333336,\n",
       " 0.3325,\n",
       " 0.4,\n",
       " 0.5,\n",
       " 0.42857142857142855,\n",
       " 0.41625,\n",
       " 0.4444444444444444,\n",
       " 0.4]"
      ]
     },
     "execution_count": 357,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg_precision[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def precise_k(res,gnd_tht,k,paper_no):\n",
    "    actual=gnd_tht[paper_no]\n",
    "    actual_auth=[i[0] for i in actual]\n",
    "    rating=[i[1] for i in actual]\n",
    "    n=len(actual)\n",
    "    soft_p=0\n",
    "    t3e=0\n",
    "    t2o=0\n",
    "    o1e=0\n",
    "    n9e=0\n",
    "    z0r=0\n",
    "    f=0\n",
    "    for i in range(k):\n",
    "        pred=res[i]\n",
    "        for j in range(n):\n",
    "            if actual_auth[j]==pred:\n",
    "                if rating[j]==3:\n",
    "                    soft_p+=1\n",
    "                    t3e+=1\n",
    "                elif rating[j]==2:\n",
    "                    soft_p+=0.67\n",
    "                    t2o+=1\n",
    "                elif rating[j]==1:\n",
    "                    soft_p+=0.33\n",
    "                    o1e+=1\n",
    "                else:\n",
    "                    z0r+=1\n",
    "                f=1\n",
    "                break\n",
    "    if f==0:\n",
    "        n9e+=1\n",
    "    soft_p=soft_p/k\n",
    "    print(z0r,o1e,t2o,t3e,n9e)\n",
    "    return soft_p\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 1 0\n",
      "0 0 1 0 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "1 0 0 0 0\n",
      "0 0 0 1 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 1 0\n",
      "0 1 0 0 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 1 0 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 1 0 0 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "1 0 0 0 0\n",
      "0 0 0 1 0\n",
      "0 0 0 0 1\n",
      "0 0 0 0 1\n",
      "0.17647058823529413\n"
     ]
    }
   ],
   "source": [
    "test_abs=pd.read_pickle('test_abs')\n",
    "n=len(test_abs)\n",
    "ctr=0\n",
    "avp=0\n",
    "valid_file=list(judge.keys())\n",
    "for i in range(n):\n",
    "    if i in valid_file:        \n",
    "        res=predict(test_abs['abstract'].iloc[i])\n",
    "        #print(res)\n",
    "        avp+=precise_k(res,judge,1,i)\n",
    "        ctr+=1\n",
    "print(avp/ctr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}