def main(web_driver): nvidia_results, ldlc_results, materiel_results, top_achat_results, pc_componentes_results = ([], [], [], [], []) if(web_driver != None): print("- Checking nvidia.com") nvidia_results = bot.check_nvidia(util.nvidia_founders, web_driver) print("- Checking material.net") materiel_results = bot.check_materiel(util.materiel_urls, web_driver) web_driver.quit() else: print(" -- Skipping Javascript based sites") print("- Checking ldlc.com") ldlc_results = bot.check_ldlc(util.ldlc_urls) print("- Checking topachat.com") top_achat_results = bot.check_top_achat(util.top_achat_url) print("- Checking pccomponentes.com") pc_componentes_results = bot.check_pc_componentes(util.pc_componentes_urls) full_list = ldlc_results + materiel_results + nvidia_results + top_achat_results + pc_componentes_results full_list = util.filter_results(full_list) util.print_results(full_list)
def run(p_method, p_normalise = True, p_reverse_results = True): all_dirs = current.train + [current.test] for d in all_dirs: vectors[d] = {} util.read_files(util.get_files(dataset.DATA_DIRECTORY + d), d, vectors) if p_normalise: util.normalise(vectors) if p_method == Method.DOT_PRODUCT: dot.compute_dot_product(current, vectors, results) elif p_method == Method.DIRICHLET: bayes.calculate(current, vectors, results) elif p_method == Method.DIFFERENCE: dot.compute_difference(current, vectors, results) elif p_method == Method.PEARSON: pearson.compute(current, vectors, results) #bayes.cal(current, vectors, results) util.print_results(results, p_reverse_results, decimal_numbers)
def run(p_method, p_normalise=True, p_reverse_results=True): all_dirs = current.train + [current.test] for d in all_dirs: vectors[d] = {} util.read_files(util.get_files(dataset.DATA_DIRECTORY + d), d, vectors) if p_normalise: util.normalise(vectors) if p_method == Method.DOT_PRODUCT: dot.compute_dot_product(current, vectors, results) elif p_method == Method.DIRICHLET: bayes.calculate(current, vectors, results) elif p_method == Method.DIFFERENCE: dot.compute_difference(current, vectors, results) elif p_method == Method.PEARSON: pearson.compute(current, vectors, results) #bayes.cal(current, vectors, results) util.print_results(results, p_reverse_results, decimal_numbers)
ticker = 'SPY' data = pd.read_csv(stock_io.format_data.format(ticker), header=0).tail(1500).reset_index(drop=True) low_vol_prediction = pd.read_csv(stock_io.file_pred_low.format(ticker), header=None) high_vol_prediction = pd.read_csv(stock_io.file_pred_high.format(ticker), header=None) final_prediction = pd.Series(low_vol_prediction[0]) + pd.Series(high_vol_prediction[0]) mse = mean_squared_error(final_prediction.values, data['close'].tail(252).values) rmse = mse ** 0.5 mape = util.mean_absolute_percentage_error(data['close'].tail(252).reset_index(drop=True), final_prediction) accuracy_act, accuracy_pred = util.get_sim_accuracy(data, final_prediction) util.print_results(accuracy_act, accuracy_pred, mse, rmse, mape) # # simulation[ma] = {'low_vol': {'prediction': low_vol_prediction, 'mse': low_vol_mse, # 'rmse': low_vol_rmse, 'mape': low_vol_mape}, # 'high_vol': {'prediction': high_vol_prediction, 'mse': high_vol_mse, # 'rmse': high_vol_rmse}, # 'final': {'prediction': final_prediction.values.tolist(), 'mse': mse, # 'rmse': rmse, 'mape': mape}, # 'accuracy': {'prediction vs close': accuracy_1, 'prediction vs prediction': accuracy_2}} # # # save simulation data here as checkpoint # with open('simulation_data.json', 'w') as fp:
train_x = train_data[emo_id, :, :-1] train_y = train_data[emo_id, :, -1:] test_x = test_data[emo_id, :, :-1] test_y = test_data[emo_id, :, -1:] k = GPy.kern.RBF(train_data[emo_id].shape[1] - 1) m = GPy.models.GPRegression(train_x, train_y, kernel=k) m.optimize_restarts(verbose=True, robust=True) preds = m.predict(test_x)[0] maes[emo] = MAE(preds, test_y) rmses[emo] = math.sqrt(MSE(preds, test_y)) pearsons[emo] = pearsonr(preds, test_y)[0] all_labels = np.concatenate((all_labels, test_y.flatten())) all_preds = np.concatenate((all_preds, preds.flatten())) all_pearson = pearsonr(all_preds, all_labels)[0] return maes, rmses, pearsons, all_pearson, all_preds if __name__ == "__main__": TRAIN_DATA = sys.argv[1] TEST_DATA = sys.argv[2] RESULTS_DIR = sys.argv[3] PREDS_DIR = sys.argv[4] train_data = scipy.io.loadmat(TRAIN_DATA)['out'] test_data = scipy.io.loadmat(TEST_DATA)['out'] maes, rmses, pearsons, all_pearson, all_preds = single_gp_experiment( train_data, test_data) np.savetxt(os.path.join(PREDS_DIR, 'single_gp.tsv'), all_preds) save_results(maes, rmses, pearsons, all_pearson, RESULTS_DIR) print_results(maes, rmses, pearsons, all_pearson)
for userID in FM_user_item_score: if user_kl_score[userID] <= threshold: continue NFM_item_scores = NFM_user_item_score[userID] DecFM_scores = [] for i in range(len(NFM_item_scores)): itemID = user_candidates[userID][i] score = NFM_item_scores[i] DecFM_scores.append([itemID, score]) DecFM_scores.sort(reverse=True, key=util.sort_function) user_item_gt.append(test_dict[userID]) user_item_pred.append([x[0] for x in DecFM_scores[:1000]]) print(f'user num {len(user_item_gt)}') test_result = util.computeTopNAccuracy(user_item_gt, user_item_pred, topN) util.print_results(None, None, test_result, None) # print("DecNFM FM") # threshold_list = [0, 0.5, 1, 2, 3, 4] # alpha_list = [1] # # alpha_list = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1] # for threshold in threshold_list: # print(f'threshold {threshold}') # for alpha in alpha_list: # print(f'alpha {alpha}') # user_item_pred = [] # user_item_gt = [] # for userID in FM_user_item_score: # if user_kl_score[userID]<=threshold: # continue # FM_item_scores = np.array(FM_user_item_score[userID])
def result(self): print_results(self.results)
if __name__ == "__main__": TRAIN_DATA = sys.argv[1] TEST_DATA = sys.argv[2] RESULTS_DIR = sys.argv[3] PREDS_DIR = sys.argv[4] PLOTS_DIR = sys.argv[5] MODEL = sys.argv[6] if MODEL == "rank": RANK = int(sys.argv[7]) else: RANK = 1 train_data = scipy.io.loadmat(TRAIN_DATA)['out'] test_data = scipy.io.loadmat(TEST_DATA)['out'] maes, rmses, pearsons, all_pearson, all_preds, B = icm_gp_experiment(train_data, test_data, MODEL, RANK) if MODEL == "rank": preds_name = '_'.join([MODEL, str(RANK) + '.tsv']) plot_name = '_'.join([MODEL, str(RANK), 'matrix.png']) else: preds_name = MODEL + '.tsv' plot_name = '_'.join([MODEL, 'matrix.png']) np.savetxt(os.path.join(PREDS_DIR, preds_name), all_preds) print_results(maes, rmses, pearsons, all_pearson) save_results(maes, rmses, pearsons, all_pearson, RESULTS_DIR) plot_coreg_matrix(B, os.path.join(PLOTS_DIR, plot_name))
def walktrap(G, t): N = G.number_of_nodes() if DEBUG: print("===== Graph Edges =====") print(G.edges) # Adjacency Matrix with self-loops A = nx.to_numpy_matrix(G, dtype=int) if DEBUG: print("===== Adjacency Matrix =====") print(A) # Diagonal Matrix D = nx.laplacian_matrix(G) + A # D^(-1/2). For distance calculation Dtemp = np.diagonal(D) if DEBUG: print("===== Diagonal Matrix's Diagonals =====") print(Dtemp) Dd = np.diag(np.power(Dtemp, (-0.5))) # Transition Matrix P P = inv(D) @ A # Transition Matrix P^t P_t = util.transition_matrix_after_t(P, t) # Initialize Partition 1, its modularity, and community part = [] for n in G.nodes: community[n] = [n] part.append([n]) partition[1] = part compute_modularity(1, G) #compute_optimal_modularity(1, G, A) # Populate initial comm dictionary for C in part: comm[str(C)] = util.community_to_adj(P_t, C) # Populate initial variance for (s, d) in G.edges: if s != d: variance[util.sort_communities_str([s], [d])] = \ compute_variance_linear(N, Dd, [s], [d]) # Start algorithm for step in range(1, N): if DEBUG: print("Step " + str(step)) # Choose two communities based on variance (C1, C2) = choose_communities() # Sorted communities C3 = util.sort_communities(C1, C2) # Insert new partition and its modularity part = list(partition.get(step)) part.remove(C1) part.remove(C2) part.append(C3) partition[step + 1] = part compute_modularity(step + 1, G) #compute_optimal_modularity(step+1, G, A) if DEBUG: print("Partition " + str(step + 1)) print(part) # Update comm dict by removing C1 and C2 # and adding C3 update_comm(C1, C2, C3) # Update new community for each node and # find all adjacent vertices in C3 adj_vertices = set() for v in C3: community[v] = sorted(C3) adj_vertices |= set(G.adj[v]) # Remove duplicates and vertices already in C3 adj_vertices = list(adj_vertices - set(C3)) # Find existing communities for each vertice adj_communities = [] for C in adj_vertices: adj_communities.append(community[C]) # Remove duplicates from adj_communities adj_communities = \ list(dict((x[0], x) for x in adj_communities).values()) # Update distance between C3 and its adjacent communities for C in adj_communities: var = 0 if check_compute_variance(C1, C2, C): var = compute_variance_constant(C1, C2, C) else: var = compute_variance_linear(N, Dd, C3, C) update_variance(C1, C2, C3, C, var) if DEBUG: print("Variance: ") print(variance) if DEBUG: print("===== Partitions =====") print(partition) print("===== Modularities =====") print(Q) util.print_results(partition, Q) bp = partition[max(Q, key=Q.get)] # Uncomment for Graph Plot # util.graph_plot(G, bp) # Return best partition return bp