def MAE_Generate_resultFile(K_start, K_end, K_step, path, path_train, path_test): rec = Recommendation(path, path_train, path_test) K = K_start result_file = os.getcwd() + '\\result\\resultOfMAE_' + os.path.basename( path) + '.csv' with open(result_file, 'w') as result_f: result_f.write( 'A Hybrid User Similarity Model for Collaborative Filtering\n') result_f.write( 'num_user:%d\nnum_items:%d\nranting:%d\nSparsity level:%.3f\n' % (rec.num_users, rec.num_items, rec.num_rating, rec.num_rating / (rec.num_items * rec.num_users))) result_f.write('{}'.format('K') + '\t' + 'MAE' + '\t' + 'NMAE' + '\n') while K <= K_end: preditmatrix_bingxing = np.load( os.getcwd() + '\\out_file\\predictMatrix_{}_'.format(K) + os.path.basename(path_train) + '_bingxing.npy') MAE_result, NMAE_result = Evaluate_MAE_AND_NMAE( preditmatrix_bingxing, rec.testMatrix) # "{} {}".format("hello", "world") line = '{}'.format(K) + '\t' + str(MAE_result) + '\t' + str( NMAE_result) + '\n' result_f.write(line) K += K_step
def add(self, entry): new_rec = Recommendation() df = pd.read_csv('data_armz.csv', sep=';') new_values = pd.DataFrame(entry) new_values.head() #Deleting possible providers - they cause the BD to be biased new_values.drop( new_values[new_values.QUANTIDADE.astype(int) > 5].index, inplace=True) new_df = df.append(new_values, ignore_index=True) new_df.to_csv(r'data_armz.csv', sep=';', index=False) status = new_rec.retrain_model() print(status) return ( "BD atualizada! Compras de quantidade superior a 5 foram desconsideradas." )
def MAE_Generate_resultFile(K_start, K_end, K_step, path, path_train, path_test, algorithmname): rec = Recommendation(path, path_train, path_test) K = K_start if algorithmname == 'PCC': result_file = os.getcwd() + '\\result\\PCC\\MAE_' + os.path.basename(path) + '.csv' if algorithmname == 'Hybird': result_file = os.getcwd() + '\\result\\Hybird\\resultOfMAE_' + os.path.basename(path) + '.csv' with open(result_file, 'w') as result_f: if algorithmname == 'PCC': result_f.write('PCC Model for Collaborative Filtering\n') if algorithmname == 'Hybird': result_f.write('A Hybrid User Similarity Model for Collaborative Filtering\n') result_f.write('num_user:%d\nnum_items:%d\nranting:%d\nSparsity level:%.3f\n' % ( rec.num_users, rec.num_items, rec.num_rating, rec.num_rating / (rec.num_items * rec.num_users))) result_f.write("%6.6s\t%6.6s\t%6.6s\n" % ('K', 'MAE', 'NMAE')) while K <= K_end: # pcc if algorithmname == 'PCC': preditmatrix_bingxing = np.load( os.getcwd() + '\\out_file\\PCC\\PCC_predictMatrix_{}_'.format(K) + os.path.basename( path_train) + '_bingxing.npy') # Hybird if algorithmname == 'Hybird': preditmatrix_bingxing = np.load( os.getcwd() + '\\out_file\\Hybird\\predictMatrix_{}_'.format(K) + os.path.basename( path_train) + '_bingxing.npy') MAE_result, NMAE_result = Evaluate_MAE_AND_NMAE(preditmatrix_bingxing, rec.testMatrix) # "{} {}".format("hello", "world") line = "%6.6s\t%6.6s\t%6.6s\n" % (K, str(MAE_result), str(NMAE_result)) result_f.write(line) K += K_step
def Generate_HR_resultfile(K_start, K_end, K_step, path, path_train, path_test, top_k, dataname): rec = Recommendation(path, path_train, path_test) K = K_start result_file = os.getcwd() + '\\result\\' + dataname + '\\HR_TOP' + str( top_k) + '_' + os.path.basename(path) + '.csv' with open(result_file, 'w') as result_f: if dataname == 'PCC': result_f.write('PCC Model for Collaborative Filtering\n') filename = 'PCC_predictMatrix' if dataname == 'Hybird': result_f.write( 'A Hybrid User Similarity Model for Collaborative Filtering\n') filename = 'predictMatrix' result_f.write( 'num_user:%d\nnum_items:%d\nranting:%d\nSparsity level:%.3f\n' % (rec.num_users, rec.num_items, rec.num_rating, rec.num_rating / (rec.num_items * rec.num_users))) result_f.write("%6.6s\t%6.6s\n" % ('K', 'HR')) while K <= K_end: preditmatrix_bingxing = np.load(os.getcwd() + '\\out_file\\' + dataname + '\\' + filename + '_{}_'.format(K) + os.path.basename(path_train) + '_bingxing.npy') hr_result = Evaluate_HR(preditmatrix_bingxing, rec, top_k) line = "%6.6s\t%6.6s\n" % (K, str(hr_result)) result_f.write(line) K += K_step
def HR_Generate_result(path, path_train, path_test, top_k): preditmatrix_bingxing = np.load(os.getcwd() + '\\out_file\\predictMatrix_{}_'.format(8) + os.path.basename(path_train) + '_bingxing.npy') rec = Recommendation(path, path_train, path_test) return Evaluate_HR(preditmatrix_bingxing, rec.testMatrix, top_k)
def DrawData_Distribute(dataname, trainname, testname): rec = Recommendation(dataname, trainname, testname) alldata_matrix = rec.Transform_csv_To_RatingMatrix(dataname) num_user = alldata_matrix.shape[0] count_rating_list = [] for i in range(num_user): count_rating_list.append(sp.dok_matrix.count_nonzero( alldata_matrix[i])) # 创建一个点数为 8 x 6 的窗口, 并设置分辨率为 80像素/每英寸 plt.figure(figsize=(8, 6), dpi=80) # 再创建一个规格为 1 x 1 的子图 plt.subplot(1, 1, 1) plt.margins(0.5) # 柱子总数 N = len(count_rating_list) # 包含每个柱子对应值的序列 values = count_rating_list # 包含每个柱子下标的序列 index = np.arange(N) # 柱子的宽度 width = 0.01 # 绘制柱状图, 每根柱子的颜色为紫罗兰色 p2 = plt.bar(index, values, label="rainfall", color="#87CEFA") # 设置横轴标签 plt.xlabel('UserID') # 设置纵轴标签 plt.ylabel('NumOfRating') # 添加标题 plt.title('mk-1m评分分布') print(count_rating_list) # 添加纵横轴的刻度 plt.xticks(index[np.array(count_rating_list) > 60]) # plt.xticks((index for index in range(0,num_user,10)),(i for i in range(0,num_user,10))) # 添加图例 plt.legend((u"用户的评分数量", )) plt.show()
def Generate_HR_resultfile(path, path_train, path_test, dataname): rec = Recommendation(path, path_train, path_test) top_k = 5 result_file = os.getcwd( ) + '\\result\\' + dataname + '\\HR' + '_' + os.path.basename( path) + '.csv' with open(result_file, 'w') as result_f: result_f.write( 'Deep Matrix Factorization Models for Recommender Systems \n') filename = 'predictMatrix' result_f.write( 'num_user:%d\nnum_items:%d\nranting:%d\nSparsity level:%.3f\n' % (rec.num_users, rec.num_items, rec.num_rating, rec.num_rating / (rec.num_items * rec.num_users))) result_f.write("%9.9s\t%6.6s\n" % ('item_topk', 'HR')) while top_k <= 10: preditmatrix_bingxing = np.load(os.getcwd() + '\\out_file\\' + dataname + '\\' + filename + '_' + os.path.basename(path_train) + '_DMF.npy') hr_result = Evaluate_HR(preditmatrix_bingxing, rec, top_k) line = "%9.9s\t%6.6s\n" % (top_k, str(hr_result)) result_f.write(line) top_k += 5
def __init__(self, main, ad, influence, recommendation, input, graph, env, people): self.mainConfig = main self.influenceConfig = influence self.adConfig = ad self.recommendationConfig = recommendation self.inputConfig = input self.graphConfig = graph self.envConfig = env self.graph = people self.environment = Environment(self.graph, self.envConfig) pygame.init() surface = pygame.display.set_mode((1920, 1080)) pygame.display.set_caption("User Interactions") clock = pygame.time.Clock() self.graphDrawrer = GraphDrawrer(self.graph, self.mainConfig, self.influenceConfig, self.adConfig, self.recommendationConfig, self.graphConfig, self.envConfig) counter = 0 record = {} if self.mainConfig.influence and self.influenceConfig.type == "1": influence = Influence1(self.graph) influence.initialiseGraph() influence.startingNodes(int(self.influenceConfig.seed)) if self.mainConfig.influence and self.influenceConfig.type == "2": influence = Influence2(self.graph) influence.initialiseGraph() influence.startingNodes(int(self.influenceConfig.seed)) if self.mainConfig.recommendation: recommendation = Recommendation(self.graph) recommendation.intialise(self.recommendationConfig.seed) for person in self.graph.people: person.item1 = recommendation.getRecommendation(person, "item1") for person in self.graph.people: person.item2 = recommendation.getRecommendation(person, "item2") for person in self.graph.people: person.item3 = recommendation.getRecommendation(person, "item3") if self.mainConfig.social: social = Social(self.graph, self.graphDrawrer) if int(self.inputConfig.cull) < len(self.graph.connections): self.graph.trim(int(self.inputConfig.cull)) for n in range(0,10): for connection in self.graph.connections: if not (connection.between[0] in self.graph.people): self.graph.connections.remove(connection) for connection in self.graph.connections: if not (connection.between[1] in self.graph.people): self.graph.connections.remove(connection) # LineIntersection(self.graph) for n in range(0, 20): Layout(self.graph).force_directed() if self.mainConfig.second: graph = pygame.transform.scale(self.graphDrawrer.make_frame(True), (960 , 1080)) env = pygame.transform.scale(self.environment.make_frame(), (960, 1080)) surface.blit(graph, (0, 0)) surface.blit(env, (960, 0)) else: surface.blit(self.graphDrawrer.make_frame(True), (0,0)) pygame.display.update() clock.tick(60) # LineIntersection(self.graph) if self.mainConfig.advert: viral = Viral(self.graph, float(self.adConfig.seed), float(self.adConfig.email), float(self.adConfig.ad), float(self.adConfig.mu), float(self.adConfig.sigma)) for person in self.graph.people: person.totalPart = 0 viral.makeCampaign(self.graph) viral.seedEmail(self.graph, 5, 0) viral.seedAdvert(self.graph, 0.1, 0) record[counter] = viral.record(self.graph, 0) while self.graphDrawrer.go: counter += 1 if self.mainConfig.social: if (counter%60 == 0): for person in self.graph.people: social.checkWall(person) if random.random() < 0.1: social.postPhoto(person) if random.random() < 0.1: social.postStatus(person) if self.mainConfig.second: graph = pygame.transform.scale(self.graphDrawrer.make_frame(), (960 , 1080)) env = pygame.transform.scale(self.environment.make_frame(), (960, 1080)) surface.blit(graph, (0, 0)) surface.blit(env, (960, 0)) else: surface.blit(self.graphDrawrer.make_frame(), (0,0)) pygame.display.update() clock.tick(60) if counter % 5 == 0: if self.mainConfig.advert: viral.checkEmail(self.graph, 0) record[counter] = viral.record(self.graph, 0) if self.mainConfig.influence: influence.process(counter) Plotter(record)
def runAlgorithms(self, algorithms, diffLists): self.startTime = datetime.datetime.now() timeRun = self.startTime.strftime('_%m_%d_%H_%M') filenameWriteRegret = os.path.join(save_address, 'AccRegret' + timeRun + '.csv') filenameWritePara = os.path.join( save_address, 'ParameterEstimation' + timeRun + '.csv') # compute co-theta for every user tim_ = [] BatchCumlateRegret = {} AlgRegret = {} CoThetaVDiffList = {} RDiffList = {} RVDiffList = {} CoThetaVDiff = {} RDiff = {} RVDiff = {} Var = {} # Initialization userSize = len(self.users) for alg_name, alg in algorithms.items(): AlgRegret[alg_name] = [] BatchCumlateRegret[alg_name] = [] Var[alg_name] = [] with open(filenameWriteRegret, 'w') as f: f.write('Time(Iteration)') f.write( ',' + ','.join([str(alg_name) for alg_name in algorithms.iterkeys()])) f.write('\n') with open(filenameWritePara, 'w') as f: f.write('Time(Iteration)') diffLists.initial_write(f) f.write('\n') # Training shuffle(self.articles) for iter_ in range(self.training_iterations): article = self.articles[iter_] for u in self.users: noise = self.noise() reward = self.reward.getReward(u, article) reward += noise for alg_name, alg in algorithms.items(): alg.updateParameters(article, reward, u.id) if 'syncCoLinUCB' in algorithms: algorithms['syncCoLinUCB'].LateUpdate() #Testing for iter_ in range(self.testing_iterations): total = 0 counter = 0 for u in self.users: self.regulateArticlePool() # select random articles noise = self.noise() #get optimal reward for user x at time t #pool_copy = copy.deepcopy(self.articlePool) OptimalReward, OptimalArticle = self.reward.getOptimalReward( u, self.articlePool) # print "Optimal Reward", OptimalReward #OptimalReward = self.reward.getOptimalRecommendationReward(u, self.articlePool, self.k) OptimalReward += noise for alg_name, alg in algorithms.items(): if alg_name == 'FairUCB': recommendation = alg.createIncentivizedRecommendation( self.articlePool, u.id, self.k) total += recommendation.k counter += 1 # Have the user choose what is the best article for them article, incentive = u.chooseArticle(recommendation) # Tell the system the users choice best_rec = Recommendation(1, [article]) noise = self.noise() reward, pickedArticle = self.reward.getRecommendationReward( u, best_rec, noise) u.updateParameters(pickedArticle.contextFeatureVector, reward) else: recommendation = alg.createRecommendation( self.articlePool, u.id, self.k) # Assuming that the user will always be selecting one item for each iteration #pickedArticle = recommendation.articles[0] reward, pickedArticle = self.reward.getRecommendationReward( u, recommendation, noise) # print "ActualReward", reward if (self.testing_method == "online"): alg.updateParameters(pickedArticle, reward, u.id) #alg.updateRecommendationParameters(recommendation, rewardList, u.id) if alg_name == 'CLUB': n_components = alg.updateGraphClusters( u.id, 'False') # print "Regret", float(OptimalReward - reward) regret = OptimalReward - reward AlgRegret[alg_name].append(regret) if u.id == 0: if alg_name in [ 'LBFGS_random', 'LBFGS_random_around', 'LinUCB', 'LBFGS_gradient_inc' ]: means, vars = alg.getProb(self.articlePool, u.id) Var[alg_name].append(vars[0]) # #update parameter estimation record diffLists.update_parameters(alg_name, self, u, alg, pickedArticle, reward, noise) if 'syncCoLinUCB' in algorithms: algorithms['syncCoLinUCB'].LateUpdate() diffLists.append_to_lists(userSize) if iter_ % self.batchSize == 0: self.batchRecord(iter_) tim_.append(iter_) for alg_name in algorithms.iterkeys(): BatchCumlateRegret[alg_name].append( sum(AlgRegret[alg_name])) with open(filenameWriteRegret, 'a+') as f: f.write(str(iter_)) f.write(',' + ','.join([ str(BatchCumlateRegret[alg_name][-1]) for alg_name in algorithms.iterkeys() ])) f.write('\n') with open(filenameWritePara, 'a+') as f: f.write(str(iter_)) diffLists.iteration_write(f) f.write('\n') if (self.plot == True): # only plot # plot the results f, axa = plt.subplots(1, sharex=True) for alg_name in algorithms.iterkeys(): axa.plot(tim_, BatchCumlateRegret[alg_name], label=alg_name) print '%s: %.2f' % (alg_name, BatchCumlateRegret[alg_name][-1]) axa.legend(loc='upper left', prop={'size': 9}) axa.set_xlabel("Iteration") axa.set_ylabel("Regret") axa.set_title("Accumulated Regret") plt.show() # plot the estimation error of co-theta f, axa = plt.subplots(1, sharex=True) time = range(self.testing_iterations) diffLists.plot_diff_lists(axa, time) axa.legend(loc='upper right', prop={'size': 6}) axa.set_xlabel("Iteration") axa.set_ylabel("L2 Diff") axa.set_yscale('log') axa.set_title("Parameter estimation error") plt.show() finalRegret = {} for alg_name in algorithms.iterkeys(): finalRegret[alg_name] = BatchCumlateRegret[alg_name][:-1] return finalRegret
num_users = test.shape[0] num_items = test.shape[1] print(num_users) print(num_items) for (u, i) in test.keys(): user_input.append(u) item_input.append(i) labels.append(test[u, i]) print(len(user_input)) print('加载数据完成!') return user_input, item_input, labels if __name__ == '__main__': list_dataset = ntf.get_dataset_path(1) recommemdation = Recommendation(list_dataset[0], list_dataset[1], list_dataset[2]) modelsavepath = os.getcwd() + '\\model\\' + os.path.basename( list_dataset[0]) + '_model.ckpt' num_users, num_items = recommemdation.num_users, recommemdation.num_items # 定义输入输出 # 用的就是训练矩阵预测测试的值 embedding = a = np.asarray(recommemdation.trainMatrix.toarray()) keep_prob = tf.placeholder(tf.float32) with tf.name_scope('input_vector_user'): user_index = tf.placeholder(dtype='int32', shape=(None), name='user_index-input') user_vector = tf.nn.embedding_lookup(embedding, user_index) with tf.name_scope('input_vector_item'): item_index = tf.placeholder(dtype='int32', shape=(None),
import sys sys.path.append(".") from flask import Flask, jsonify, request, json, Response import json import pandas as pd from Recommendation import Recommendation from CartRecom import CartRecom from Bicluster.BiclusterRecom import BiclusterRecom from BdManagement import BdManagement from ClientRecom import ClientRecom app = Flask(__name__) retrain_recom = Recommendation() cart_recom = CartRecom() bicluster_recom = BiclusterRecom() bd_manager = BdManagement() client_recom = ClientRecom() # ************************************************************* # # *********************** MÉTODOS GET ************************* # # ************************************************************* # @app.route('/') def home(): return "Você se conectou."
# Pcc_MAE = pd.DataFrame(columns=name,data=[mae_pcc,nmae_pcc]) # Pcc_MAE.to_csv(os.getcwd()+'\\result\\PCC\\Pcc_MAE_'+ os.path.basename(list_dataset[0])+'.csv') ## Hybird mae_hybird, nmae_hybird = MAE_Generate_resultFile(4, 20, 4, list_dataset[0], list_dataset[1], list_dataset[2], 'Hybird') Hybird_MAE = pd.DataFrame(columns=name,data=[mae_hybird,nmae_hybird]) Hybird_MAE.to_csv(os.getcwd()+'\\result\\Hybird\\Hybird_MAE_'+ os.path.basename(list_dataset[0])+'.csv') ''' ## PMF # predictmatrix_pmf= np.load(os.getcwd()+'\\out_file\\PMF\\predictMatrix_m1-200-1000.csv_train.csv_PMF.npy') predictmatrix_pmf = np.load(os.getcwd() + '\\out_file\\PMF\\predictMatrix_' + os.path.basename(list_dataset[1]) + '_PMF.npy') Pmf_mae, Pmf_nmae = Evaluate_MAE_AND_NMAE( predictmatrix_pmf, Recommendation(list_dataset[0], list_dataset[1], list_dataset[2]).testMatrix) Pmf_MAE = pd.DataFrame(columns=['pmf_MAE_NMAE'], data=[Pmf_mae, Pmf_nmae]) Pmf_MAE.to_csv(os.getcwd() + '\\result\\PMF\\Pmf_MAE' + os.path.basename(list_dataset[0]) + '.csv') ''' # HR ## PCC # Generate_HR_resultfile(4, 20, 4, list_dataset[0], list_dataset[1], list_dataset[2], 5, 'PCC') # Generate_HR_resultfile(4, 20, 4, list_dataset[0], list_dataset[1], list_dataset[2], 10, 'PCC') ## Hybird Generate_HR_resultfile(4, 20, 4, list_dataset[0], list_dataset[1], list_dataset[2], 5, 'Hybird') Generate_HR_resultfile(4, 20, 4, list_dataset[0], list_dataset[1], list_dataset[2], 10, 'Hybird') ''' ## Pmf rec = Recommendation(list_dataset[0], list_dataset[1], list_dataset[2]) predictmatrix_pmf_hr = np.load(os.getcwd() +
typeparam = int(request.args.get('type')) userid = request.args.get('userid') if typeparam == 0: result = engine.listPopulerSong() return flask.Response(result) elif typeparam == 1: result = engine.ratingbyUserID(int(userid)) return jsonify(result) elif typeparam == 2: result = engine.listPopulerGenre(int(userid)) return flask.Response(result) elif typeparam == 3: return None elif typeparam == 4: return jsonify(request.args) mining = Mining() @app.route('/test', methods=['POST']) def test(): text = request.form['text'] result = engine.spark.sql(text).toJSON().collect() return flask.Response(result) if __name__ == '__main__': engine = Recommendation() app.run(host='0.0.0.0')
def createRecommendation(self, pool_articles, userID, k): articles = self.decide(pool_articles, userID, k) recommendation = Recommendation(k, articles) return recommendation
def testAlgorithms(self, algorithms, diffLists, AlgRegret, BatchCumlateRegret,\ Var, userSize, tim_, filenameWriteRegret, filenameWritePara): #Testing for iter_ in range(self.testing_iterations): total = 0 counter = 0 for u in self.users: self.regulateArticlePool() # select random articles noise = self.noise() OptimalReward, OptimalArticle = self.reward.getOptimalReward( u, self.articlePool) OptimalReward += noise for alg_name, alg in algorithms.items(): if alg_name == 'FairUCB': recommendation = alg.createIncentivizedRecommendation( self.articlePool, u.id, self.k) total += recommendation.k counter += 1 # Have the user choose what is the best article for them article, incentive = u.chooseArticle(recommendation) # Tell the system the users choice best_rec = Recommendation(1, [article]) noise = self.noise() reward, pickedArticle = self.reward.getRecommendationReward( u, best_rec, noise) u.updateParameters(pickedArticle.contextFeatureVector, reward) else: recommendation = alg.createRecommendation( self.articlePool, u.id, self.k) # Assuming that the user will always be selecting one item for each iteration #pickedArticle = recommendation.articles[0] reward, pickedArticle = self.reward.getRecommendationReward( u, recommendation, noise) if (self.testing_method == "online"): alg.updateParameters(pickedArticle, reward, u.id) if alg_name == 'CLUB': n_components = alg.updateGraphClusters( u.id, 'False') regret = OptimalReward - reward AlgRegret[alg_name].append(regret) if u.id == 0: if alg_name in [ 'LBFGS_random', 'LBFGS_random_around', 'LinUCB', 'LBFGS_gradient_inc' ]: means, vars = alg.getProb(self.articlePool, u.id) Var[alg_name].append(vars[0]) # #update parameter estimation record diffLists.update_parameters(alg_name, self, u, alg, pickedArticle, reward, noise) if 'syncCoLinUCB' in algorithms: algorithms['syncCoLinUCB'].LateUpdate() diffLists.append_to_lists(userSize) if iter_ % self.batchSize == 0: self.batchRecord(iter_) tim_.append(iter_) for alg_name in algorithms.iterkeys(): BatchCumlateRegret[alg_name].append( sum(AlgRegret[alg_name])) with open(filenameWriteRegret, 'a+') as f: f.write(str(iter_)) f.write(',' + ','.join([ str(BatchCumlateRegret[alg_name][-1]) for alg_name in algorithms.iterkeys() ])) f.write('\n') with open(filenameWritePara, 'a+') as f: f.write(str(iter_)) diffLists.iteration_write(f) f.write('\n')
def get_user_input(self) -> None: """Designed to be the command for the button 'ENTER': Here it stores user input of ONLY the new playlist generation (link, scale, playlist name) Furthermore, it also executes recommendation and from that, also computes the link to the newly generated Spotify Playlist It then passes it on to NewPlaylistOutput, to create a Top Level window for user to access the newly generated Spotify Playlist """ # Here we update the playlist entry attribute self.playlist_entry = self._link_entry.get() # Here we update the scale entry attribute self.scale_entry = self._slider.get() # Update the desired new playlists name self.new_playlist_name = self._new_playlist_name_entry.get() self.token = self._token_entry.get() # Need to check if user has inputted everything needed, and only then go into this branch if self.playlist_entry != '' and self.scale_entry != '' \ and self.new_playlist_name != '' and self.token != '': try: tk.Label( self.root, text= 'YOUR *PLAYLIST* INFORMATION HAS BEEN RECORDED. \n THANK YOU!', font=("Proxima nova", "9", "bold"), fg='white', bg='black').grid() # Recommendation computation from module recommended_song_ids = Recommendation( self.playlist_entry, self.scale_entry, self.data_obj, self.sp, self.centroid_to_graph).action() # Generating new link new_playlist_link = SpotifyClient(recommended_song_ids, self.new_playlist_name, self.token).url # Calculating old playlist averages to display aves = [0] * 9 # 9 features num_songs = 0 for song_id in recommended_song_ids: num_songs += 1 features = self.data_obj.normalize_value( get_features(song_id, self.sp)) # Removing duration(ms) and key cols_removed_features = features[:3] + features[4:10] for i in range(len(aves)): aves[i] += cols_removed_features[i] aves = list(map(lambda ave: round(ave / num_songs * 100), aves)) output_playlist_summary = { 'Acousticness': aves[0], 'Danceability': aves[1], 'Energy': aves[2], 'Instrumentalness': aves[3], 'Valence': aves[4], 'Tempo': aves[5], 'Liveness': aves[6], 'Loudness': aves[7], 'Speechiness': aves[8] } # Running another Tkinter window (Top Level) to display # computations(aka new playlist) output_root = tk.Toplevel() output_window = NewPlaylistOutput(output_root, new_playlist_link, output_playlist_summary) output_window.run_window() output_root.mainloop() except KeyError: print( '1 hour has passed and the authorization token has expired. \n' 'Please follow the same steps to regenerate another token, and try again.' ) except TypeError: print( 'NOTICE: You have a song that is not registered with Spotify \n' 'Please input another playlist!')
def search(uid, max_distance, ideal_distance, current_location, current_time, event_location, event_time, spare_time, bias, mode): print('searching....') print('event_location', event_location) print('event_time', event_time) print('spare_time', spare_time) print('bias', bias) radius = DistanceCalculator.mile_to_meter(\ min(ideal_distance, max_distance))*\ scorer.DISTANCE_REGULARIZED print('radius', radius) keyword = set() for b in bias: keyword = keyword | set(database_getter.EVENT_TYPES[b]) if spare_time < scorer.MAX_SPARE_TIME: keyword = keyword | scorer.SHORT_STOP_TYPES else: keyword = keyword | scorer.LONG_STOP_TYPES routes = defaultdict(Route) # search nearby places around both start ptr and dest ptr for location in [current_location, event_location]: if location != None: for k in keyword: for place in FindPlaces.get_nearby_places(location=location, radius=radius, keyword=k): if place[1] not in routes: routes[place[1]] = Route(stop=place, origin=current_location, dest=event_location, mode=mode) routes[place[1]].set_staying_time(uid) for stop_id, route in routes.items(): print("=================", route.stop_name, "=================") print("goal distance scoring") route.add_score( scorer.goal_distance_func( DistanceCalculator.mile_to_meter(ideal_distance), route.total_dist)) print(route.score) print("location history scoring") route.add_score( scorer.past_location_func( database_getter.is_past_location(route.stop_id))) print(route.score) print("staying time scoring") route.add_score( scorer.staying_time_func(spare_time - route.total_time, route.staying_time)) print(route.score) print("event bias scoring") route.add_score(scorer.event_bias_func(bias, route.stop_types)) print(route.score) recommendations = [] for stop_id, route in sorted(routes.items(), key=lambda x: x[1].score, reverse=True)[:3]: report = ''' "{}" at "{}" Primary location type: "{}" It is {:.1f} miles away. It takes {} steps to walk there. =========================================================== It will take you {} minutes to walk there. You will arrive at {} if you leave now. =========================================================== After completing this walk, your steps will be {} for today. =========================================================== You can hang at this location for {} minutes before you start walking to your scheduled event. '''.format( route.stop_name, route.stop_address, route.stop_types[0], DistanceCalculator.meter_to_mile(route.origin_to_stop[0])\ if route.origin_to_stop[0] != 0 else DistanceCalculator.meter_to_mile( route.stop_to_dest[0]), route.step_to_stop \ if route.step_to_stop != 0 else route.step_to_dest, round(route.origin_to_stop[1]/60) \ if route.origin_to_stop[1] != 0 else round(route.stop_to_dest[1]/60), (current_time+timedelta( seconds=route.origin_to_stop[1])).strftime('%Y-%m-%d %H:%M:%S')\ if route.origin_to_stop[1] != 0 else (current_time+timedelta( seconds=route.origin_to_stop[1])).strftime('%Y-%m-%d %H:%M:%S'), route.step_to_stop+database_getter.get_user_current_step(uid)\ if route.step_to_stop != 0 \ else route.step_to_dest+database_getter.get_user_current_step(uid), spare_time-route.trip_time ) print(report) rec=Recommendation( uid=uid, type=0 if not bias else 1, start_time=current_time, duration=route.origin_to_stop[1] \ if route.origin_to_stop[1] != 0 else route.step_to_stop[0], place_id=route.stop_id, place_name=route.stop_name, place_address=route.stop_address, place_types=route.stop_types, steps=route.step_to_stop \ if route.step_to_stop != 0 else route.step_to_dest, report=report ) recommendations.append(rec) Recommendation.add_to_db(rec) ## TODO if len(recommendations) < 3: recommendations.append(recommendations[0]) return recommendations
def get_user_input(self) -> None: """Designed to be the command for the button 'ENTER': Here it stores user input of ONLY the new playlist generation (link, scale, playlist name) Furthermore, it also executes recommendation and from that, also computes the link to the newly generated Spotify Playlist It then passes it on to NewPlaylistOutput, to create a Top Level window for user to access the newly generated Spotify Playlist Lastly, it also computes the normalized averages of the attributes of the old inputted playlist. Assigned as a dictionary, and passed on to NewPlaylistOutput to display with bar graphs. """ # Here we update the playlist entry attribute self.playlist_entry = self._link_entry.get() # Here we update the scale entry attribute self.scale_entry = int(self._slider.get()) # Update the desired new playlists name self.new_playlist_name = self._new_playlist_name_entry.get() # Need to check if user has inputted everything needed, and only then go into this branch if self.playlist_entry != '' and self.scale_entry != '' \ and self.new_playlist_name != '': try: tk.Label(self.root, text='YOUR *PLAYLIST* INFORMATION HAS BEEN RECORDED.' ' \n THANK YOU!', font=("Proxima nova", "9", "bold"), fg='white', bg='black').grid() # Recommendation computation from module recommended_song_ids = Recommendation( self.playlist_entry, self.scale_entry, self.data_obj, self.sp, self.centroid_to_graph).action() # Generating new link # new_playlist_link = SpotifyClient(recommended_song_ids, # self.new_playlist_name).url spotify_instance = Spotify_Client() new_playlist_link = spotify_instance.create_playlist( self.new_playlist_name, recommended_song_ids) # Calculating old playlist averages to display aves = [0] * 9 # 9 features num_songs = 0 for song_id in recommended_song_ids: num_songs += 1 # features = self.data_obj.normalize_value(get_features(song_id, self.sp)) features = self.data_obj.normalize_value( spotify_instance.get_song_features(song_id)) # Removing duration(ms) and key cols_removed_features = features[:3] + features[4:10] for i in range(len(aves)): aves[i] += cols_removed_features[i] aves = list(map(lambda ave: round(ave / num_songs * 100), aves)) output_playlist_summary = { 'Acousticness': aves[0], 'Danceability': aves[1], 'Energy': aves[2], 'Instrumentalness': aves[3], 'Valence': aves[4], 'Tempo': aves[5], 'Liveness': aves[6], 'Loudness': aves[7], 'Speechiness': aves[8] } # Running another Tkinter window (Top Level) to # display computations(aka new playlist) output_root = tk.Toplevel() output_window = NewPlaylistOutput(output_root, new_playlist_link, output_playlist_summary) output_window.run_window() output_root.mainloop() # Case where there may be in song in user playlist that is not recognized by API except TypeError: print( 'There is a song in this playlist that the Spotipy API cannot read. \n' 'This is because this song is not defined in Spotify but rather ' 'it most likely is from a local file. \n Please input a new playlist! ' ) else: print('Invalid playlist entry inputs.\nPlease input all entries!.') print( 'Playlist generation over. If you want, input another playlist link, \n' 'try to visualize, or close window!')
from BooksDataSet import BooksDataSet from Recommendation import Recommendation from surprise import KNNBasic import heapq from collections import defaultdict from operator import itemgetter testSubject = '85' k = 10 user_id = 11676 data_set = BooksDataSet() users = data_set.getUsersData() books = data_set.getBooksData() ratings = data_set.getRatingsData() print('Print the loaded data') data_set.printData() print('Recommend the books based on rating count') recommendation = Recommendation() recommended_items_by_rating = recommendation.getRecommendationsByRatingCounts( ratings, books) recommendation.printItem(recommended_items_by_rating) print('Recommend the books based on collaborative user filtering algorithm') ratings_matrix = recommendation.getRecommendationsByCfUser(user_id, ratings) recommended = recommendation.recommendItem(user_id) recommendation.printRecommendations(books, recommended)
j = np.random.randint(num_items) user_input.append(user_vector_u) user_vector_j = sp.dok_matrix.transpose(train).toarray()[j] item_input.append(user_vector_j) labels.append(0) return user_input, item_input, labels if __name__ == '__main__': batch_size = 256 topK = 10 csv_path = 'C:\\Users\\suxik\\Desktop\\text\\graduation-project-\\prepare_datasets\\test.csv' csv_path1 = 'C:\\Users\\suxik\Desktop\\text\graduation-project-\\prepare_datasets\\ml-1m.train.rating' # Loading data t1 = time() Rec = Recommendation(csv_path) train, testRatings, testNegatives = Rec.ratingMatrix, Rec.testRatings, Rec.testNegatives num_users, num_items = train.shape print("Load data done [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d" % (time() - t1, num_users, num_items, train.nnz, len(testRatings))) # Build model model = get_model(num_users, num_items, layers, reg_layers) model.compile(optimizer=SGD(lr=learning_rate), loss='binary_crossentropy') # Check Init performance t1 = time() (hits, ndcgs) = evaluate_model(model, testRatings, testNegatives, topK, evaluation_threads) hr, ndcg = np.array(hits).mean(), np.array(ndcgs).mean() print('Init: HR = %.4f, NDCG = %.4f [%.1f]' % (hr, ndcg, time() - t1))