235 lines
9.0 KiB
Python
235 lines
9.0 KiB
Python
import os
|
|
import sys
|
|
import numpy as np
|
|
import pandas as pd
|
|
import math
|
|
from sklearn.preprocessing import normalize
|
|
from tqdm import tqdm
|
|
from datetime import datetime, date
|
|
import random
|
|
import scipy.sparse as sparse
|
|
from os import listdir
|
|
from os.path import isfile, join
|
|
from collections import defaultdict
|
|
|
|
|
|
def evaluate(test,
|
|
estimations_df,
|
|
reco,
|
|
super_reactions=[4,5],
|
|
topK=10):
|
|
|
|
estimations_df=estimations_df.copy()
|
|
reco=reco.copy()
|
|
test_df=test.copy()
|
|
|
|
# prepare testset
|
|
test_df.columns=['user', 'item', 'rating', 'timestamp']
|
|
test_df['user_code'] = test_df['user'].astype("category").cat.codes
|
|
test_df['item_code'] = test_df['item'].astype("category").cat.codes
|
|
|
|
user_code_id = dict(enumerate(test_df['user'].astype("category").cat.categories))
|
|
user_id_code = dict((v, k) for k, v in user_code_id.items())
|
|
item_code_id = dict(enumerate(test_df['item'].astype("category").cat.categories))
|
|
item_id_code = dict((v, k) for k, v in item_code_id.items())
|
|
|
|
test_ui = sparse.csr_matrix((test_df['rating'], (test_df['user_code'], test_df['item_code'])))
|
|
|
|
#prepare estimations
|
|
estimations_df.columns=['user', 'item' ,'score']
|
|
estimations_df['user_code']=[user_id_code[user] for user in estimations_df['user']]
|
|
estimations_df['item_code']=[item_id_code[item] for item in estimations_df['item']]
|
|
estimations=sparse.csr_matrix((estimations_df['score'], (estimations_df['user_code'], estimations_df['item_code'])), shape=test_ui.shape)
|
|
|
|
#compute_estimations
|
|
estimations_df=estimations_metrics(test_ui, estimations)
|
|
|
|
#prepare reco
|
|
users=reco[:,:1]
|
|
items=reco[:,1::2]
|
|
# Let's use inner ids instead of real ones
|
|
users=np.vectorize(lambda x: user_id_code.setdefault(x, -1))(users) # maybe users we recommend are not in test set
|
|
items=np.vectorize(lambda x: item_id_code.setdefault(x, -1))(items) # maybe items we recommend are not in test set
|
|
# Let's put them into one array
|
|
reco=np.concatenate((users, items), axis=1)
|
|
|
|
#compute ranking metrics
|
|
ranking_df=ranking_metrics(test_ui, reco, super_reactions=super_reactions, topK=topK)
|
|
|
|
#compute diversity metrics
|
|
diversity_df=diversity_metrics(test_ui, reco, topK)
|
|
|
|
result=pd.concat([estimations_df, ranking_df, diversity_df], axis=1)
|
|
|
|
return(result)
|
|
|
|
|
|
def ranking_metrics(test_ui, reco, super_reactions=[], topK=10):
|
|
|
|
nb_items=test_ui.shape[1]
|
|
relevant_users, super_relevant_users, prec, rec, F_1, F_05, prec_super, rec_super, ndcg, mAP, MRR, LAUC, HR, F_2=\
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
|
|
|
cg = (1.0 / np.log2(np.arange(2, topK + 2)))
|
|
cg_sum = np.cumsum(cg)
|
|
|
|
for (nb_user, user) in tqdm(enumerate(reco[:,0])):
|
|
u_rated_items=test_ui.indices[test_ui.indptr[user]:test_ui.indptr[user+1]]
|
|
nb_u_rated_items=len(u_rated_items)
|
|
if nb_u_rated_items>0: # skip users with no items in test set (still possible that there will be no super items)
|
|
relevant_users+=1
|
|
|
|
u_super_items=u_rated_items[np.vectorize(lambda x: x in super_reactions)\
|
|
(test_ui.data[test_ui.indptr[user]:test_ui.indptr[user+1]])]
|
|
# more natural seems u_super_items=[item for item in u_rated_items if test_ui[user,item] in super_reactions]
|
|
# but accesing test_ui[user,item] is expensive -we should avoid doing it
|
|
if len(u_super_items)>0:
|
|
super_relevant_users+=1
|
|
|
|
user_successes=np.zeros(topK)
|
|
nb_user_successes=0
|
|
user_super_successes=np.zeros(topK)
|
|
nb_user_super_successes=0
|
|
|
|
# evaluation
|
|
for (item_position,item) in enumerate(reco[nb_user,1:topK+1]):
|
|
if item in u_rated_items:
|
|
user_successes[item_position]=1
|
|
nb_user_successes+=1
|
|
if item in u_super_items:
|
|
user_super_successes[item_position]=1
|
|
nb_user_super_successes+=1
|
|
|
|
prec_u=nb_user_successes/topK
|
|
prec+=prec_u
|
|
|
|
rec_u=nb_user_successes/nb_u_rated_items
|
|
rec+=rec_u
|
|
|
|
F_1+=2*(prec_u*rec_u)/(prec_u+rec_u) if prec_u+rec_u>0 else 0
|
|
F_05+=(0.5**2+1)*(prec_u*rec_u)/(0.5**2*prec_u+rec_u) if prec_u+rec_u>0 else 0
|
|
|
|
prec_super+=nb_user_super_successes/topK
|
|
rec_super+=nb_user_super_successes/max(len(u_super_items),1)
|
|
ndcg+=np.dot(user_successes,cg)/cg_sum[min(topK, nb_u_rated_items)-1]
|
|
|
|
cumsum_successes=np.cumsum(user_successes)
|
|
mAP+=np.dot(cumsum_successes/np.arange(1,topK+1), user_successes)/min(topK, nb_u_rated_items)
|
|
MRR+=1/(user_successes.nonzero()[0][0]+1) if user_successes.nonzero()[0].size>0 else 0
|
|
LAUC+=(np.dot(cumsum_successes, 1-user_successes)+\
|
|
(nb_user_successes+nb_u_rated_items)/2*((nb_items-nb_u_rated_items)-(topK-nb_user_successes)))/\
|
|
((nb_items-nb_u_rated_items)*nb_u_rated_items)
|
|
|
|
HR+=nb_user_successes>0
|
|
|
|
##############################################################################
|
|
#TASK
|
|
|
|
F_2 += 5 * (prec_u * rec_u) / (4 * prec_u + rec_u) if prec_u + rec_u > 0 else 0
|
|
##############################################################################
|
|
|
|
|
|
|
|
result=[]
|
|
result.append(('precision', prec/relevant_users))
|
|
result.append(('recall', rec/relevant_users))
|
|
result.append(('F_1', F_1/relevant_users))
|
|
result.append(('F_05', F_05/relevant_users))
|
|
result.append(('precision_super', prec_super/super_relevant_users))
|
|
result.append(('recall_super', rec_super/super_relevant_users))
|
|
result.append(('NDCG', ndcg/relevant_users))
|
|
result.append(('mAP', mAP/relevant_users))
|
|
result.append(('MRR', MRR/relevant_users))
|
|
result.append(('LAUC', LAUC/relevant_users))
|
|
result.append(('HR', HR/relevant_users))
|
|
result.append(('F_2', F_2/relevant_users))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
df_result=pd.DataFrame()
|
|
if len(result)>0:
|
|
df_result=(pd.DataFrame(list(zip(*result))[1])).T
|
|
df_result.columns=list(zip(*result))[0]
|
|
|
|
##############################################################################
|
|
#TASK
|
|
#Get average of all values
|
|
df_result["Whole_average"] = df_result.mean(1)
|
|
##############################################################################
|
|
return df_result
|
|
|
|
|
|
def estimations_metrics(test_ui, estimations):
|
|
result=[]
|
|
|
|
RMSE=(np.sum((estimations.data-test_ui.data)**2)/estimations.nnz)**(1/2)
|
|
result.append(['RMSE', RMSE])
|
|
|
|
MAE=np.sum(abs(estimations.data-test_ui.data))/estimations.nnz
|
|
result.append(['MAE', MAE])
|
|
|
|
df_result=pd.DataFrame()
|
|
if len(result)>0:
|
|
df_result=(pd.DataFrame(list(zip(*result))[1])).T
|
|
df_result.columns=list(zip(*result))[0]
|
|
return df_result
|
|
|
|
def diversity_metrics(test_ui, reco, topK=10):
|
|
|
|
frequencies=defaultdict(int)
|
|
|
|
for item in list(set(test_ui.indices)):
|
|
frequencies[item]=0
|
|
|
|
for item in reco[:,1:].flat:
|
|
frequencies[item]+=1
|
|
|
|
nb_reco_outside_test=frequencies[-1]
|
|
del frequencies[-1]
|
|
|
|
frequencies=np.array(list(frequencies.values()))
|
|
|
|
nb_rec_items=len(frequencies[frequencies>0])
|
|
nb_reco_inside_test=np.sum(frequencies)
|
|
|
|
frequencies=frequencies/np.sum(frequencies)
|
|
frequencies=np.sort(frequencies)
|
|
|
|
with np.errstate(divide='ignore'): # let's put zeros we items with 0 frequency and ignore division warning
|
|
log_frequencies=np.nan_to_num(np.log(frequencies), posinf=0, neginf=0)
|
|
|
|
result=[]
|
|
result.append(('Reco in test', nb_reco_inside_test/(nb_reco_inside_test+nb_reco_outside_test)))
|
|
result.append(('Test coverage', nb_rec_items/test_ui.shape[1]))
|
|
result.append(('Shannon', -np.dot(frequencies, log_frequencies)))
|
|
result.append(('Gini', np.dot(frequencies, np.arange(1-len(frequencies), len(frequencies), 2))/(len(frequencies)-1)))
|
|
|
|
df_result=(pd.DataFrame(list(zip(*result))[1])).T
|
|
df_result.columns=list(zip(*result))[0]
|
|
return df_result
|
|
|
|
|
|
|
|
def evaluate_all(test,
|
|
dir_path="Recommendations generated/ml-100k/",
|
|
super_reactions=[4,5],
|
|
topK=10):
|
|
|
|
models = list(set(['_'.join(f.split('_')[:2]) for f in listdir(dir_path)
|
|
if isfile(dir_path+f)]))
|
|
result=[]
|
|
for model in models:
|
|
estimations_df=pd.read_csv('{}{}_estimations.csv'.format(dir_path, model), header=None)
|
|
reco=np.loadtxt('{}{}_reco.csv'.format(dir_path, model), delimiter=',')
|
|
to_append=evaluate(test, estimations_df, reco, super_reactions, topK)
|
|
|
|
to_append.insert(0, "Model", model)
|
|
result.append(to_append)
|
|
result=pd.concat(result)
|
|
result=result.sort_values(by='recall', ascending=False)
|
|
|
|
return result |