def evaluate_eurm(self, target_pids): assert(self.mode=='offline') eurm = sps.csr_matrix(self.eurm[target_pids]) eurm = post.eurm_remove_seed(eurm, self.dr) rec_list = post.eurm_to_recommendation_list(eurm) res = self.ev.evaluate(rec_list, str(self) , verbose=self.verbose_ev, return_result='all') return res
def recsys(shrink): t1 = 0.25 t2 = 0.65 c = 0.4 shrink = 50 k = 200 config = ('l=%.2f t1=%.2f t2=%.2f c=%.2f k=%d shrink=%d binary=False' % (l, t1, t2, c, k, shrink)) #print(config) sim = ss.s_plus_similarity(urm.T, urm, k=k, t1=t1, t2=t2, c=c, l=l, normalization=True, shrink=shrink, binary=False, verbose=True) #Computing ratings and remove seed eurm = ss.dot_product(t_urm, sim.T, k=750) del sim eurm = eurm_remove_seed(eurm, dr) #evaluation res = ev.evaluate(eurm_to_recommendation_list(eurm), 'ciao', verbose=False) del eurm return res[0:3], config
def fast_evaluate_eurm(self, eurm, target_pids=None, name='fast_evaluation', verbose=True, do_plot=False, show_plot=False, save=False, return_result='all'): """ Directly evaluate a eurm of shape (10K, 2.2M) removing seed tracks and converting it into a recommendation list. """ if target_pids is None: target_pids = self.datareader.get_test_pids() eurm = sparse.csr_matrix(eurm[target_pids]) #eurm = post.eurm_remove_seed(eurm, datareader=self.datareader) no needed, now it's done in the next function rec_list = post.eurm_to_recommendation_list(eurm, verbose=False, datareader=self.datareader, remove_seed=True) result = self.evaluate(rec_list, name, verbose=verbose, return_result=return_result, do_plot=do_plot, show_plot=show_plot, save=save) return result
def recsys(alpha, beta): alpha = alpha beta = beta k = 200 shrink = 100 config = ('alpha=%.2f beta=%.2f k=%d shrink=%d binary=False' % (alpha, beta, k, shrink)) #print(config) sim = p3r3.p3alpha_rp3beta_similarity(p_iu, p_ui, pop, k=k, shrink=shrink, alpha=alpha, beta=beta, verbose=True, mode=1) #Computing ratings and remove seed eurm = ss.dot_product(t_urm, sim, k=750) del sim eurm = eurm_remove_seed(eurm, dr) #evaluation res = ev.evaluate(eurm_to_recommendation_list(eurm), 'ciao', verbose=False) del eurm return res[0:3], config
def fitnessFunction(self, individual): # Convert list into a numpy array individual = np.array(individual) # Make a copy of the UCM and filter it for each column if self.verbose: print('Filtering UCM...') start = time.time() UCM_filtered = self.UCM.copy() UCM_filtered = UCM_filtered.astype(np.float64) inplace_csr_column_scale(UCM_filtered, individual) if self.verbose: print('UCM filtered in', time.time() - start, 'sec') # Compute similarity if self.verbose: print('Computing similarity...') start = time.time() similarity = tversky_similarity(UCM_filtered, shrink=200, alpha=0.1, beta=1, target_items=self.test_playlists_indices, binary=False) similarity = similarity.tocsr() if self.verbose: print('Similarity computed in', time.time() - start, 'sec') # Compute eurm if self.verbose: print('Computing eurm...') start = time.time() eurm = dot_product(similarity, self.URM_train, k=500) if self.verbose: print('eurm computed in', time.time() - start, 'sec') print('Converting eurm in csr...') start = time.time() eurm = eurm.tocsr() eurm = eurm[self.test_playlists_indices, :] if self.verbose: print('eurm converted in', time.time() - start, 'sec') # Evaluate rec_list = eurm_to_recommendation_list(eurm) print('current', self.current) score_cat_1 = self.evaluator.evaluate_single_metric(rec_list, name='Genetic', metric='prec', level='track', cat=1, verbose=False) score_cat_2 = self.evaluator.evaluate_single_metric(rec_list, name='Genetic', metric='prec', level='track', cat=2, verbose=False) score = (score_cat_1 + score_cat_2) / 2 self.current += 1 if self.verbose: print(score) print("Numfeatures {}".format(np.sum(individual))) print('\n') return score,
def evaluate_shrinked(W_sparse, urm_shrinked, pids_shrinked ): W_sparse = W_sparse[pids_shrinked] eurm = dot_product(W_sparse, urm_shrinked, k=750).tocsr() eurm = eurm_remove_seed(eurm=eurm) rec_list = eurm_to_recommendation_list(eurm) ev.evaluate(recommendation_list=rec_list, name="slim_structure_parametribase_BPR_epoca_0_noepoche", return_overall_mean=False, show_plot=False, do_plot=True)
def recsys(shrink): config = ('alpha=0.4 k=200 shrink=%d binary=False' % (shrink)) print(config) sim = ss.cosine_similarity(urm.T, urm, k=200, alpha=0.4, shrink=shrink, binary=False, verbose=True) #Computing ratings and remove seed eurm = ss.dot_product(t_urm, sim.T, k=750) del sim eurm = eurm_remove_seed(eurm, dr) #evaluation res = ev.evaluate(eurm_to_recommendation_list(eurm), 'ciao', verbose=False) del eurm return res[0:3], config
def obiettivo(self, x): eurm = sum(x[i] * matrix for i, matrix in enumerate(self.matrices_array)) # real objective function ris = -self.ev.evaluate_single_metric(eurm_to_recommendation_list( eurm, cat=self.cat, remove_seed=False, verbose=False), verbose=False, cat=self.cat, name="ens" + str(self.cat), metric=self.target_metric, level='track') # memory variables if self.x0 is None: self.x0 = [[x]] self.y0 = [ris] else: self.x0.append(x) self.y0.append(ris) self.global_counter += 1 if ris < self.best_score: print("[NEW BEST]") self.pretty_print(ris, x) self.best_score = ris self.best_params = x.copy() self.best_params_dict = dict(zip(self.matrices_names, x.copy())) b = list() if os.path.isfile("best/cat" + str(self.cat) + ".plk"): b.append(self.best_params_dict) b.append(ris) save_obj(b, "best/cat" + str(self.cat)) else: b.append(self.best_params_dict) b.append(ris) save_obj(b, "best/cat" + str(self.cat)) elif self.verbose: self.pretty_print(ris, x) return ris
def recsys(shrink): alpha = 0.25 beta = 0.65 k = 200 config = ('alpha=%.2f beta=%.2f k=%d shrink=%d binary=False' % (alpha, beta, k, shrink)) #print(config) sim = ss.tversky_similarity(urm.T, urm, k=k, alpha=alpha, beta=beta, shrink=shrink, binary=False, verbose=True) #Computing ratings and remove seed eurm = ss.dot_product(t_urm, sim.T, k=750) del sim eurm = eurm_remove_seed(eurm, dr) #evaluation res = ev.evaluate(eurm_to_recommendation_list(eurm), 'ciao', verbose=False) del eurm return res[0:3], config
rprec = [] for i in range(0, 10): print("[ Ensembling cat", i + 1, "]") rprec.append(ensembler(matrix[i], w[i], normalization_type="max")) res = sps.vstack(rprec).tocsr() import time name = "ensemble-" + mode + "-data-" + time.strftime( "%x") + "-" + time.strftime("%X") name = name.replace("/", "_") sps.save_npz("results/" + name + ".npz", res) print("[ Initizalizing Datereader ]") dr = Datareader(verbose=False, mode=mode, only_load="False") res = eurm_to_recommendation_list(res, datareader=dr) if mode == "offline": print("[ Initizalizing Evaluator ]") ev = Evaluator(dr) ev.evaluate(res, name="ens") if mode == "online": print("[ Initizalizing Submitter ]") sb = Submitter(dr) sb.submit(recommendation_list=res, name=name, track="main", verify=True, gzipped=False)
matrix = [a, b, c, d, e, f, g] a = float(sys.argv[1]) b = float(sys.argv[2]) c = float(sys.argv[3]) d = float(sys.argv[4]) e = float(sys.argv[5]) f = float(sys.argv[6]) g = float(sys.argv[7]) res = ensembler(matrix, [a, b, c, d, e, f, g], normalization_type="max") ev = Evaluator(dr) ret = [ -ev.evaluate_single_metric(eurm_to_recommendation_list(res, cat=cat), cat=cat, name="ens" + str(cat), metric='prec', level='track') ] if os.path.isfile("best.npy"): best = np.load("best.npy") if ret[0] < best[-1].astype(np.float): b = sys.argv[1:] b.append(ret[0]) np.save("best", b) else: b = sys.argv[1:] b.append(ret[0])
# rp3b = sps.load_npz(ROOT_DIR + "/data/sub/EURM-rp3beta-online.npz") # knn_c_i_al = sps.load_npz(ROOT_DIR + "/data/sub/KNN CONTENT ITEM-album-top_k=850-sm_type=cosine-shrink=100.npz") # knn_c_i_ar = sps.load_npz(ROOT_DIR + "/data/sub/KNN CONTENT ITEM-artist-top_k=850-sm_type=cosine-shrink=100.npz") nlp = sps.load_npz(ROOT_DIR + "/data/eurm_nlp_offline.npz") # cf_u = sps.load_npz(ROOT_DIR + "/data/sub/eurm_cfu_online.npz") eurm_ens = sps.load_npz(ROOT_DIR + "/data/ENSEMBLED.npz") #matrix = [rp3b, knn_c_i_ar, knn_c_i_al, nlp, cf_u] #eurm_ens = ensembler(matrix, [0.720, 0.113, 0.177, 0.194, 1.0], normalization_type="max") # HOLEBOOST hb = HoleBoost(similarity=sim, eurm=eurm_ens, datareader=dr, norm=norm_l1_row) eurm_ens = hb.boost_eurm(categories=[8, 10], k=300, gamma=5) # NINEBOOST nb = TailBoost(similarity=sim, eurm=eurm_ens, datareader=dr, norm=norm_l2_row) eurm_ens = nb.boost_eurm(last_tracks=10, k=100, gamma=0.01) rec_list = eurm_to_recommendation_list(eurm_ens) rec_list_nlp = eurm_to_recommendation_list(nlp) indices = dr.get_test_pids_indices(cat=1) for i in indices: rec_list[i] = rec_list_nlp[i] # EVALUATION ev.evaluate(rec_list, name='ens_with_cfu_nineboosted', show_plot=False)
print(arg) best = list(arg[1:].astype(np.float)) w.append(best) for i in tqdm(range(1,11)): if mode == "offline": CBF_ALBUM = sps.load_npz(mode+"/offline-cbf_item_album-cat"+str(i)+".npz") CBF_ARTISTA = sps.load_npz(mode+"/offline-cbf_item_artist-cat"+str(i)+".npz") NLP = norm_max_row(sps.load_npz(mode + "/nlp_eurm_offline_bm25-cat" + str(1) + ".npz")) RP3BETA = sps.load_npz(mode+"/offline-rp3beta-cat"+str(i)+".npz") CF_USER = sps.load_npz(mode + "/cfu_eurm-cat"+str(i)+".npz") SLIM = sps.load_npz(mode +"/slim_bpr_completo_test1-cat"+str(i)+".npz") CBF_USER_ARTIST = sps.load_npz(mode +"/eurm_cbfu_artists_offline-cat"+str(i)+".npz") matrix = [CBF_ALBUM, CBF_ARTISTA, NLP, RP3BETA, CF_USER, SLIM, CBF_USER_ARTIST] we = w[i-1] res.append(ensembler(matrix, we, normalization_type="lele")) ret = sps.vstack(res).tocsr() if mode == "offline": ev.evaluate(eurm_to_recommendation_list(ret), "best_test", verbose=True) # sps.save_npz("ensemble_per_cat_"+mode+"_new_data_28_maggio.npz", ret) if mode == "online": sb = Submitter(dr) sb.submit(recommendation_list=eurm_to_recommendation_list_submission(ret), name="best_test", track="main", verify=True, gzipped=False)
""" simple code to evaluate a recommender, you need a sparse matrix of shape (10k,2,2kk) """ from utils.datareader import Datareader from utils.evaluator import Evaluator import utils.post_processing as post import scipy.sparse as sps filename = "file.npz" output_name = "matrix_factorization" if __name__ == '__main__': dr = Datareader(mode="offline", only_load=True) ev = Evaluator(dr) pids = dr.get_test_playlists().transpose()[0] algorithm_eurm_full = sps.load_npz(filename) algorithm_eurm_small = algorithm_eurm_full[pids] ev.evaluate(post.eurm_to_recommendation_list(algorithm_eurm_small), name=output_name, verbose=True, show_plot=True, save=True)
k=knn, verbose=1, binary=False) sim = sim.tocsr() # Prediction eurm = dot_product(sim, urm, k=topk) eurm = eurm.tocsr() eurm = eurm[test_pids, :] # Save eurm if save_eurm: sps.save_npz('eurm_' + name + '_' + mode + '.npz', eurm) # Evaluation ev.evaluate(recommendation_list=eurm_to_recommendation_list( eurm, datareader=dr), name=complete_name) elif mode == "online": # Initialization dr = Datareader(verbose=False, mode=mode, only_load=True) test_pids = list(dr.get_test_pids()) sb = Submitter(dr) urm = dr.get_urm() # UCM ucm_artists = dr.get_ucm_albums() ucm_artists = bm25_row(ucm_artists) # Do not train on challenge set ucm_artists_T = ucm_artists.copy()
from utils.post_processing import eurm_to_recommendation_list, eurm_remove_seed from personal.Ervin.Word2Vec_recommender import W2VRecommender from personal.Ervin.ItemRank import ItemRank from personal.Ervin.tf_collaborative_user import TF_collaborative_user from recommenders.knn_collaborative_item import Knn_collaborative_item if __name__ == '__main__': dr = Datareader(only_load=True, mode='offline', test_num='1', verbose=False) pid = dr.get_test_playlists().transpose()[0] urm = dr.get_urm() urm.data = np.ones(len(urm.data)) ev = Evaluator(dr) TFRec = Knn_collaborative_item() W2V = W2VRecommender() TFRec.fit(urm, pid) W2V.fit(urm, pid) TFRec.compute_model(verbose=True, top_k=850) TFRec.compute_rating(top_k=750, verbose=True, small=True) W2V.compute_model(verbose=True, size=50, window=None) W2V.compute_rating(verbose=True, small=True, top_k=750) TFRec.eurm = norm_l1_row(eurm_remove_seed(TFRec.eurm, dr)) W2V.eurm = norm_l1_row(eurm_remove_seed(W2V.eurm, dr)) for alpha in np.arange(0.9, 0, -0.1): print('[ Alpha = {:.1f}]'.format(alpha)) eurm = alpha * TFRec.eurm + (1-alpha)*W2V.eurm ev.evaluate(recommendation_list=eurm_to_recommendation_list(eurm, remove_seed=False, datareader=dr), name="KNNItem_W2V"+str(alpha), old_mode=False, save=True)
#Computing similarity/model rec.compute_model(top_k=knn, sm_type=tversky_similarity, shrink=200, alpha=0.1, beta=1, binary=True, verbose=True) #Computing ratings rec.compute_rating(top_k=topk, verbose=True, small=True) #evaluation and saving sps.save_npz(complete_name + ".npz", rec.eurm) ev = Evaluator(dr) ev.evaluate(eurm_to_recommendation_list(rec.eurm), name=complete_name) elif mode == "online": """Submission""" #Data initialization dr = Datareader(verbose=True, mode=mode, only_load=False) #Recommender algorithm initialization rec = Knn_collabrative_user() #Getting for the recommender algorithm urm = dr.get_urm() pid = dr.get_test_pids() #Fitting data rec.fit(urm, pid)
warnings.warn( 'This function still use the old version of the remove seed, it should be replaced soon by the one in post_processing class' ) self.urm = sps.csr_matrix(self.urm[self.pid]) tmp = self.urm.tocoo() row = tmp.row col = tmp.col min = self.eurm.tocoo().min() self.eurm = sps.lil_matrix(self.eurm) self.eurm[row, col] = -1 self.eurm = sps.csr_matrix(self.eurm) return self.eurm if __name__ == '__main__': from utils.datareader import Datareader dr = Datareader(verbose=False, mode="offline", only_load="False") rec = Top_pop() rec.fit(dr.get_urm(), dr.get_test_playlists().transpose()[0]) eurm = rec.compute_rating().tocsr() sps.save_npz("top_pop online.npz", eurm.tocsr()) exit() import utils.evaluator as ev from utils.post_processing import eurm_to_recommendation_list eva = ev.Evaluator(dr) eva.evaluate(eurm_to_recommendation_list(eurm), "cacca TOPTOP")
# INJECTING URM POS with only last 25 songs rec.urm = dr.get_last_n_songs_urm(n=cut) #Computing ratings rec.compute_rating(top_k=topk, verbose=True, small=True) lastsongs_eurm = rec.eurm.copy() sps.save_npz(complete_name + "_LAST.npz", rec.eurm) eurm = norm_max_row(normal_eurm) + norm_max_row(lastsongs_eurm) sps.save_npz(complete_name + ".npz", rec.eurm) #evaluation ev = Evaluator(dr) ev.evaluate(eurm_to_recommendation_list(rec.eurm), name, verbose=True) #TODO if mode == "online": ### Submission ### #Data initialization dr = Datareader(verbose=True, mode='online', only_load=True) #Recommender algorithm initialization rec = R_p_3_beta() #Submitter initialization sb = Submitter(dr)
# Compute similarity (playlists x playlists) sim = tversky_similarity(ucm, ucm.T, k=knn, shrink=0, alpha=1, beta=0.1) sim = sim.tocsr() # Recommendation eurm = dot_product(sim, urm, k=topk) eurm = eurm.tocsr() eurm = eurm[test_pids, :] rec_list = eurm_to_recommendation_list(eurm, dr) if save_eurm: sps.save_npz(mode + "_" + name + ".npz", eurm, compressed=False) # Submission ev = Evaluator(dr) ev.evaluate(rec_list, name=name) elif mode == 'online': # Setup sb = Submitter(dr) urm = dr.get_urm() test_pids = dr.get_test_pids() # Init object
matrix = [a, b, c, d, e, f, g, h] a = float(sys.argv[1]) b = float(sys.argv[2]) c = float(sys.argv[3]) d = float(sys.argv[4]) e = float(sys.argv[5]) f = float(sys.argv[6]) g = float(sys.argv[7]) h = float(sys.argv[8]) res = ensembler(matrix, [a, b, c, d, e, f, g, h], normalization_type="max") ev = Evaluator(dr) ret = [-ev.evaluate_single_metric(eurm_to_recommendation_list(res, cat=cat), cat=cat, name="ens"+str(cat), metric='prec', level='track')] if os.path.isfile("best.npy"): best = np.load("best.npy") if ret[0] < best[-1].astype(np.float): b = sys.argv[1:] b.append(ret[0]) np.save("best", b) else: b = sys.argv[1:] b.append(ret[0]) np.save("best", b) np.save("ret", ret)
eurm_knn_album = sps.load_npz( ROOT_DIR + "/data/offline/ENSEMBLE - KNN CONTENT ITEM - album - top_k = 100 - sm_type = cosine - shrink = 100.npz" ) eurm_knn_artist = sps.load_npz( ROOT_DIR + "/data/offline/ENSEMBLE - KNN CONTENT ITEM - artist - top_k = 100 - sm_type = cosine - shrink = 100.npz" ) eurm_rp3 = sps.load_npz( ROOT_DIR + "/data/offline/ENSEMBLE - RP3BETA - top_k=100 - shrink=100 - alpha=0.5 - beta=0.4.npz" ) eurm_nlp = sps.load_npz(ROOT_DIR + "/data/eurm_nlp_offline.npz") # Convert in rec_list rec_list_rp3 = eurm_to_recommendation_list(eurm_rp3) rec_list_knn_album = eurm_to_recommendation_list(eurm_knn_album) rec_list_knn_artist = eurm_to_recommendation_list(eurm_knn_artist) rec_list_nlp = eurm_to_recommendation_list(eurm_nlp) # Round Robin RR = RoundRobin( [rec_list_rp3, rec_list_knn_album, rec_list_knn_artist, rec_list_nlp], weights=None) rec_list_rr = rec_list_rp3 for k in [20, 50, 70, 90, 100, 120, 150, 180, 200, 230]: for i in tqdm(range(1000, len(rec_list_rp3)), desc='Round Robin ' + k): prediction = RR.rr_avg(playlist_index=i, rec_index=0, cut_off=k, K=k) #prediction = RR.rr_jmp(playlist_index=i, K=k)
URM_validation=None) cfw.fit() weights = sps.diags(cfw.D_best) sps.save_npz("ICM_fw_maurizio", weights) ICM_weighted = ICM.dot(weights) sps.save_npz("ICM_fw_maurizio", ICM_weighted) ######## NOI urm = dr.get_urm() pid = dr.get_test_pids() cbfi = Knn_content_item() cbfi.fit(urm, ICM_weighted, pid) cbfi.compute_model(top_k=knn, sm_type=COSINE, shrink=0, binary=False, verbose=True) cbfi.compute_rating(top_k=topk, verbose=True, small=True) sps.save_npz(complete_name + ".npz", cbfi.eurm) ev = Evaluator(dr) ev.evaluate(recommendation_list=eurm_to_recommendation_list(cbfi.eurm), name=complete_name)
def objective_function(x): global best_score, global_counter, best_params, start_time, x0,y0 eurm = sum(x[i] * matrix for i, matrix in enumerate(matrices_array)) # real objective function ris = -ev.evaluate_single_metric(eurm_to_recommendation_list(eurm, cat=cat, remove_seed=False, verbose=False), verbose=False, cat=cat, name="ens" + str(cat), metric=target_metric, level='track') if x0 is None: x0 = [x] y0 = [ris] else: x0.append(x) y0.append(ris) global_counter += 1 if ris < best_score: best_score = ris best_params = x.copy() pretty_print(ris, x, start_time) best_params_dict = dict(zip(matrices_names+['norm'], x.copy()+[norm_name])) if not os.path.exists(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/'): os.mkdir(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/') dump_params_dict(your_dict=best_params_dict, name= "cat" + str(cat) + "_params_dict", path=ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/') elif global_counter%25==0: pretty_print(ris, x, start_time) ## print and save memory x0,y0 every 25 calls if global_counter%25==0: if not os.path.exists(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/memory/'): os.mkdir(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/memory/') save_obj(x0, "cat" + str(cat) + "_x0_MEMORY", path=ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/memory/') save_obj(y0, "cat" + str(cat) + "_y0_MEMORY", path=ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/memory/') #### condition with no results if global_counter == 10 and best_score ==0: best_params_dict = dict(zip(matrices_names + ['norm'], [0.0 for a in range(len(x))] + [norm_name])) if not os.path.exists(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/'): os.mkdir(ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/') dump_params_dict(your_dict=best_params_dict, name="cat" + str(cat) + "_params_dict", path=ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/') pretty_print(ris, x, start_time) print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") print("CAT"+str(cat)+" HAS NO lines, EXIT ") exit() start_time = time.time() return ris
import utils.pre_processing as pre from boosts.hole_boost import HoleBoost from utils.datareader import Datareader from utils.definitions import ROOT_DIR from utils.evaluator import Evaluator from utils.post_processing import eurm_to_recommendation_list # Initialization dr = Datareader(mode='offline', only_load=True) ev = Evaluator(dr) # Load matrices eurm = sparse.load_npz(ROOT_DIR + '/data/eurm_rp3_offline.npz') sim = sparse.load_npz(ROOT_DIR + '/data/sim_offline.npz') print('Loaded') # Normalization eurm = pre.norm_l2_row(eurm) sim = pre.norm_l2_row(sim) # HoleBoost h = HoleBoost(sim, eurm, dr) eurm_b = h.boost_eurm(categories=[2, 3, 4, 5, 6, 7, 8, 9, 10], k=200, gamma=10) #sparse.save_npz(ROOT_DIR + '/data/eurm_boosted_online.npz', eurm_b) rec_list = eurm_to_recommendation_list(eurm_b) # Evaluation ev.evaluate(rec_list, name='rp3_l2_all_200_10', save=True, show_plot=False)
best_params_dict = read_params_dict(name='cat' + str(cat) + '_params_dict', path=ROOT_DIR + '/bayesian_scikit/' + configuration_name + '/best_params/') norm = best_params_dict['norm'] del best_params_dict['norm'] # cutting and dot the value from ensemble eurms_full = [ value_from_bayesian * norms[norm](matrices_loaded[name][start_index:end_index]) for name, value_from_bayesian in best_params_dict.items()] # and summing up eurms_cutted[cat-1] = sum( [ matrix for matrix in eurms_full] ) # adding to reclist rec_list[start_index:end_index] = eurm_to_recommendation_list(eurm=eurms_cutted[cat-1], cat=cat, verbose=False)[start_index:end_index] eurm = eurms_cutted[0] for i in range(1,10): eurm = sps.vstack([eurm, eurms_cutted[i]]) sps.save_npz(file='../'+configuration_name+'/ensembled_'+configuration_name+'_'+mode, matrix=eurm) if mode=='offline': ev = Evaluator(dr) ev.evaluate(recommendation_list=rec_list, name=configuration_name) else: sb = Submitter(dr) sb.submit(recommendation_list=rec_list, name=configuration_name)
# TopPop Album album = artists_dic[track_ind] playlists = ucm_album.indices[ucm_album.indptr[album]:ucm_album. indptr[album + 1]] top = urm[playlists].sum(axis=0).A1.astype(np.int32) track_ind_rec = top.argsort()[-501:][::-1] eurm2[row, track_ind_rec] = top[track_ind_rec] eurm1 = eurm1.tocsr()[pids_all] eurm2 = eurm2.tocsr()[pids_all] eurm1 = eurm_remove_seed(eurm1, dr) eurm2 = eurm_remove_seed(eurm2, dr) sps.save_npz("test1.npz", eurm1) rec_list1 = eurm_to_recommendation_list(eurm1) rec_list2 = eurm_to_recommendation_list(eurm2) rec_list3 = append_rec_list(rec_list1 + rec_list2) ev = Evaluator(dr) ev.evaluate(rec_list1, name="enstest", level='track') ev.evaluate(rec_list2, name="enstest", level='track') ev.evaluate(rec_list3, name="enstest", level='track') # rec.append(list(top_p))
self.eurm = self.eurm.T self.eurm.eliminate_zeros() if verbose: print("time: " + str(int(time.time() - start_time) / 60)) return self.eurm.tocsr() if __name__ == '__main__': dr = Datareader(only_load=True, mode='offline', test_num='1', verbose=False) pid = dr.get_test_playlists().transpose()[0] urm = dr.get_urm() ev = Evaluator(dr) urm.data = np.ones(urm.data.shape[0]) IR = ItemRank() IR.fit(urm, pid) IR.compute_model(verbose=True, top_k=850) IR.compute_rating(top_k=750, verbose=True, small=True, iter=2) ev.evaluate(recommendation_list=eurm_to_recommendation_list( IR.eurm, remove_seed=True, datareader=dr), name="ItemRank", old_mode=False)