os.makedirs(args.dataset + '_log', exist_ok=True) if args.debug: f = open(os.path.join(args.dataset + '_log', 'debug_log.txt'), 'w') f.write('\n'.join([str(k) + ',' + str(v) for k, v in sorted(vars(args).items(), key=lambda x: x[0])])) f.write('\n') else: f = open(os.path.join(args.dataset + '_log', 'exp_log.txt'), 'w') f.write('\n'.join([str(k) + ',' + str(v) for k, v in sorted(vars(args).items(), key=lambda x: x[0])])) f.write('\n') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(sequences_train, contexts_train, usernum, itemnum, context_dim, batch_size=args.batch_size, maxlen=args.maxlen, n_workers=12) model = Model(usernum, itemnum, context_dim, args) sess.run(tf.initialize_all_variables()) T = 0.0 seqs, contexts, pos_contexts, test_items, valid_users = prepare_test_data(dataset=dataset, args=args) seqs_2, contexts_2, pos_contexts_2, test_items_2, valid_users_2 = prepare_valid_data(dataset=dataset, args=args) sample_seq = seqs[7] sample_context = contexts[7] sample_pos_context = pos_contexts[7] sample_test_item = test_items[7] sample_test_user = valid_users[7] i = 0
dataset = data_partition(args.dataset) [user_train, user_valid, user_test, usernum, itemnum] = dataset num_batch = len(user_train) / args.batch_size cc = 0.0 for u in user_train: cc += len(user_train[u]) print 'average sequence length: %.2f' % (cc / len(user_train)) f = open(os.path.join(args.dataset + '_' + args.train_dir, 'log.txt'), 'w') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(user_train, usernum, itemnum, batch_size=args.batch_size, maxlen=args.maxlen, n_workers=3) valid_sampler = WarpSampler(user_valid, usernum, itemnum, batch_size=usernum, maxlen=args.maxlen, n_workers=1) test_sampler = WarpSampler(user_test, usernum, itemnum, batch_size=usernum, maxlen=args.maxlen, n_workers=1) # import IPython; IPython.embed() model = Model(usernum, itemnum, args) sess.run(tf.initialize_all_variables()) T = 0.0 t0 = time.time() try: for epoch in range(1, args.num_epochs + 1): losses = [] for step in tqdm(range(num_batch), total=num_batch, ncols=70, leave=False, unit='b', desc='Epoch=%d'%epoch): u, seq, pos, neg = sampler.next_batch()
n_users, n_items = user_item_matrix.shape # make feature as dense matrix dense_features = None Ks_test_recalls = np.zeros([10, 6]) Ks_test_precisions = np.zeros([10, 6]) Aupr_values = np.zeros([10, 1]) for num in range(1, 11): print("Experiment num ", num, "\n") np.random.seed(num) train, valid, test = split_data(user_item_matrix, split_ratio=(3, 1, 1)) sampler = WarpSampler(train, batch_size=BATCH_SIZE, n_negative=N_NEGATIVE, check_negative=True) model = CML( n_users, n_items, # enable feature projection features=dense_features, assmat=train, embed_dim=EMBED_DIM, margin=2.0, clip_norm=1.1, master_learning_rate=0.1, # the size of the hidden layer in the feature projector NN hidden_layer_dim=512, # dropout rate between hidden layer and output layer in the feature projector NN
for r in Item[item]['related']: Item[item]['related'][r] = set(Item[item]['related'][r]) item_i_mask_list = [] item_i_mask = np.zeros([num_rel + 1]) for r in Item[item]['related'].keys(): if len(Item[item]['related'][r]) != 0: item_i_mask[invRelationships[r] + 1] = 1.0 item_i_mask_list.append(invRelationships[r] + 1) item_i_mask[0] = 1.0 item_i_mask_list.append(0) Item[item]['mask'] = item_i_mask Item[item]['mask_list'] = item_i_mask_list # define sampler with multi-processing sampler = WarpSampler(user_train, user_train_set, Item, usernum, itemnum, Relationships, batch_size=args.batch_size, n_workers=4) valid_sampler = WarpSampler(user_train, user_train_set, Item, usernum, itemnum, Relationships, batch_size=args.batch_size, is_test=True, User_test=user_validation, n_workers=2) test_sampler = WarpSampler(user_train, user_train_set, Item, usernum, itemnum, Relationships, batch_size=args.batch_size, is_test=True, User_test=user_test, n_workers=2) sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) model = MoHR(usernum, itemnum, Relationships, args) sess.run(tf.initialize_all_variables()) best_valid_auc = 0.5 best_iter = 0 num_batch = oneiteration / args.batch_size
def train(self): print('train start') #train, valid, artists_dic, albums_dic, titles, titles_len = spotify(self.mode, self.valid) sampler = WarpSampler(self.train_data, self.unigram_probs, batch_size=self.batch_size, n_negative=self.n_negative, check_negative=True) # sample some users to calculate recall validation items = self.from_numpy(np.arange(self.n_items)) prev_recall = 0 recall_score = 0.0000001 prev_ndcg = 0 ndcg_score = 0.0000001 epoch = 1 while epoch <= self.num_epochs: self.model.train() if prev_recall < recall_score and prev_ndcg < ndcg_score: prev_recall = recall_score prev_ndcg = ndcg_score self.save_model() print('Model saved') # train model losses = [] # run n mini-batches #try: # for obj in gc.get_objects(): # if torch.is_tensor(obj) or (hasattr(obj, 'data') and torch.is_tensor(obj.data)): # print(type(obj), obj.size()) #except: # pass #self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr) for i in tqdm(range(self.evaluation_every_n_batchs), desc="Optimizing..."): user_pos, neg = sampler.next_batch() pos_artists = self.from_numpy(self.artists_dic[user_pos[:, 1]]) pos_albums = self.from_numpy(self.albums_dic[user_pos[:, 1]]) neg_artists = self.from_numpy( np.array([ self.artists_dic[negative_sample] for negative_sample in neg ])).type(torch.long) neg_albums = self.from_numpy( np.array([ self.albums_dic[negative_sample] for negative_sample in neg ])).type(torch.long) titles = None #self.from_numpy(self.titles[user_pos[:, 0]]) titles_len = None #self.from_numpy(self.titles_len[user_pos[:, 0]]) user_pos = self.from_numpy(user_pos).type(torch.long) neg = self.from_numpy(neg).type(torch.long) self.model.zero_grad() pos_distances, distance_to_neg_items, closest_negative_item_distances = self.model( user_pos, pos_artists, pos_albums, neg, neg_artists, neg_albums, titles, titles_len) # / (self.optim_size / self.batch_size) loss = self.get_loss(pos_distances, distance_to_neg_items, closest_negative_item_distances) loss.backward(retain_graph=False) #torch.nn.utils.clip_grad_norm(self.model.parameters(), self.clip_norm) self.optimizer.step() self.clip_by_norm(self.model.module.user_embeddings) self.clip_by_norm(self.model.module.item_embeddings) self.clip_by_norm(self.model.module.artist_embeddings) self.clip_by_norm(self.model.module.album_embeddings) #self.clip_by_norm(self.model.title_embeddings) #self.model.title_embeddings.weight.data = self.clip_by_norm(self.model.title_embeddings.weight.data) #if (i+1) % (self.optim_size / self.batch_size) == 0 or i == self.evaluation_every_n_batchs-1: # self.optimizer.step() # self.model.zero_grad() losses.append(loss.detach().cpu().numpy()) torch.cuda.empty_cache() print("\nTraining loss {}".format(np.mean(losses))) epoch += 1 # compute recall in chunks to utilize speedup provided by Tensorflow artists = self.from_numpy(self.artists_dic) albums = self.from_numpy(self.albums_dic) titles = self.from_numpy(self.titles) titles_len = self.from_numpy(self.titles_len) #ratios = self.from_numpy(self.ratios) self.model.eval() for i in range(10): # create evaluator on validation set validation_recall = RecallEvaluator(self.model, self.train_data, self.valid_data[i]) # compute recall on validate set valid_recalls = [] valid_ndcgs = [] valid_users = np.array( list(set(self.valid_data[i].nonzero()[0])), ) #valid_users = list(set(self.valid_data[i].nonzero()[0])) for user_chunk in toolz.partition_all(50, valid_users): user_chunk = self.from_numpy(np.array(user_chunk)).type( torch.long) recall, ndcg = validation_recall.eval( user_chunk, items, artists, albums, titles[user_chunk], titles_len[user_chunk], None) valid_recalls.extend(recall) valid_ndcgs.extend(ndcg) #for user_chunk in valid_users: #items = np.array(self.val_candidates[user_chunk]) #if len(items) > 50: #artists = self.from_numpy(self.artists_dic[items]).type(torch.long) #albums = self.from_numpy(self.albums_dic[items]).type(torch.long) #items = self.from_numpy(items).type(torch.long) #user_chunk = self.from_numpy(np.array([user_chunk])).type(torch.long) #recall, ndcg = validation_recall.eval(user_chunk, items, artists, albums, titles[user_chunk], titles_len[user_chunk], ratios[user_chunk-990000]) #valid_recalls.extend([recall]) #valid_ndcgs.extend([ndcg]) #else: #print(len(items)) #valid_recalls.extend([[0.0]]) #valid_ndcgs.extend([[0.0]]) recall_score = np.mean(valid_recalls) ndcg_score = np.mean(valid_ndcgs) print('\nNo. {}'.format(i)) print("Recall on (sampled) validation set: {}".format( recall_score)) print( "Ndcg on (sampled) validation set: {}".format(ndcg_score)) print('Epoch: {}'.format(epoch)) torch.cuda.empty_cache() self.predict()
if __name__ == '__main__': args = parse_args() os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu np.random.seed(2017) random_seed = 2017 tf.compat.v1.set_random_seed(random_seed) print("%s reading dataset %s" % (datetime.now(), args.dataset)) train, valid = dataset_to_uimatrix(args.train_data, args.test_data) n_users, n_items = train.shape print("%s #users=%d, #items=%d" % (datetime.now(), n_users, n_items)) sampler = WarpSampler(train, batch_size=args.batch_size, n_negative=args.num_negative, check_negative=True) # WITHOUT features # Train a user-item joint embedding, where the items a user likes will be pulled closer to this users. # Once the embedding is trained, the recommendations are made by finding the k-Nearest-Neighbor to each user. model = CML( n_users, n_items, # set features to None to disable feature projection features=None, # size of embedding embed_dim=args.embed_dim, # the size of hinge loss margin. margin=args.margin, # clip the embedding so that their norm <= clip_norm
def main(): prepare_env() dataset, user_train, usernum, itemnum, num_batch = load_dataset() sampler = WarpSampler( user_train, usernum, itemnum, args=args, batch_size=args.batch_size, maxlen=args.maxlen, threshold_user=args.threshold_user, threshold_item=args.threshold_item, n_workers=3, ) graph, model, num_experts, expert_paths, global_step, saver = create_model( usernum, itemnum, args) config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True with tf.Session(config=config, graph=graph) as sess: sess.run(tf.global_variables_initializer()) if num_experts > 1: for i, path in enumerate( expert_paths): # restore experts' variables restore_collection(path, "expert_{}".format(i), sess, graph) best_result = 0.0 best_res_path = os.path.join(args.train_dir, args.best_res_log) if os.path.isfile(best_res_path): with open(best_res_path, 'r') as inf: best_result = float(inf.readline().strip()) best_step = 0 no_improve = 0 save_path = tf.train.latest_checkpoint(args.train_dir) if save_path: saver.restore(sess, save_path) print("[restored] {}".format(save_path)) else: save_path = saver.save(sess, os.path.join(args.train_dir, "model.ckpt"), global_step) print("[saved] {}".format(save_path)) T = 0.0 t0 = time.time() t_valid = evaluate_valid(model, dataset, args, sess) print("[init] time = {}, best = {}, eval HR@{} = {}, HR@{} = {}],". format(time.time() - t0, best_result, args.k, t_valid[0], args.k1, t_valid[1])) if args.std_test: t0 = time.time() t_test = evaluate(model, dataset, args, sess) print( "[init] time = {}, test NDCG{} = {}, NDCG{} = {}, HR{} = {}, HR{} = {}]" .format(time.time() - t0, args.k, t_test[0], args.k1, t_test[1], args.k, t_test[2], args.k1, t_test[3])) t0 = time.time() for epoch in range(1, args.num_epochs + 1): # for step in tqdm(range(num_batch), total=num_batch, ncols=70, leave=False, unit='b'): total_loss = 0.0 for step in range(num_batch): u, seq, pos, neg = sampler.next_batch() if num_experts > 1: log_freq = 100 loss, _, global_step_val = sess.run( [model.loss, model.train_op, global_step], { model.u: u, model.input_seq: seq, model.pos: pos, model.is_training: True }) if step % log_freq == 0: print("[step-{}] {}/{}, avg_loss = {}".format( global_step_val, step + 1, num_batch, total_loss / log_freq)) total_loss = 0.0 else: total_loss += loss else: user_emb_table, item_emb_table, attention, auc, loss, _, global_step_val = sess.run( [ model.user_emb_table, model.item_emb_table, model.attention, model.auc, model.loss, model.train_op, global_step ], { model.u: u, model.input_seq: seq, model.pos: pos, model.neg: neg, model.is_training: True }) print("[step-{}] {}/{}, auc = {}, loss = {}".format( global_step_val, step + 1, num_batch, auc, loss)) sys.stdout.flush() if epoch % args.eval_freq == 0: t1 = time.time() T += t1 - t0 # t_test = evaluate(model, dataset, args, sess) t_valid = evaluate_valid(model, dataset, args, sess) t2 = time.time() # print("[{0}, {1}, {2}, {3}, {4}, {5}],".format(epoch, T, t_valid[0], t_valid[1], t_test[0], t_test[1])) print( "[epoch = {}, time = {} (train/eval = {}/{}), HR@{} = {}, HR@{} = {}]," .format(epoch, T, t1 - t0, t2 - t1, args.k, t_valid[0], args.k1, t_valid[1])) t0 = t2 # early stopping if t_valid[args.eval_tgt_idx] > best_result: print("[best_result] {} (step-{}) < {} (step-{})".format( best_result, best_step, t_valid[args.eval_tgt_idx], global_step_val)) best_result = t_valid[args.eval_tgt_idx] best_step = global_step_val # ckpt_paths = glob(os.path.join(args.train_dir, "model.ckpt*")) # for path in ckpt_paths: # os.remove(path) # print("[removed] {}".format(path)) with open(best_res_path, 'w') as outf: outf.write("{}".format(best_result)) save_path = saver.save( sess, os.path.join(args.train_dir, "model.ckpt"), global_step_val) print("[saved] {}".format(save_path)) no_improve = 0 else: print("[best_result] {} (step-{}) > {} (step-{})".format( best_result, best_step, t_valid[args.eval_tgt_idx], global_step_val)) no_improve += args.eval_freq if args.early_stop_epochs < 0: # turn off early stopping save_path = saver.save( sess, os.path.join(args.train_dir, "model.ckpt"), global_step_val) print("[saved] {}".format(save_path)) else: if no_improve >= args.early_stop_epochs: print( "[stop training] no improvement for {} epochs". format(no_improve)) break sys.stdout.flush() if args.std_test: t_test = evaluate(model, dataset, args, sess) print( "[final] time = {}, test NDCG{} = {}, NDCG{} = {}, HR{} = {}, HR{} = {}]" .format(time.time() - t0, args.k, t_test[0], args.k1, t_test[1], args.k, t_test[2], args.k1, t_test[3])) sampler.close() print("[Done]")
for user in range(usernum): oneiteration += len(user_train[user]['consume']) for item in set(user_train[user]['produce']): if item in owner: print "multiple_creators!" owner[item] = user for item in range(itemnum): if item not in owner: print "missing creator!" break oneiteration = min(1000000, oneiteration) sampler = WarpSampler(user_train, user_validation, user_test, owner, usernum, itemnum, batch_size=args.batch_size, n_workers=1) sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) model = Model(usernum, itemnum, args) sess.run(tf.initialize_all_variables()) best_valid_auc = 0.5 best_iter = 0 for i in range(args.maximum_epochs): for _ in range(oneiteration / args.batch_size): batch = sampler.next_train_batch() batch_u, batch_i, batch_j, batch_oi, batch_oj = batch
model = CAST6(usernum, itemnum, ratingnum, args) elif args.model == "cast_7": model = CAST7(usernum, itemnum, ratingnum, args) elif args.model == "cast_8": model = CAST8(usernum, itemnum, ratingnum, args) elif args.model == "cast_9": model = CAST9(usernum, itemnum, ratingnum, args) elif args.model == "sasrec": model = SASRec(usernum, itemnum, args) elif args.model == "sasrec_static": model = SASRec(usernum, itemnum, args, static=True) # SAMPLER print('usernum', usernum, 'itemnum', itemnum) sampler = WarpSampler(args, train, usernum, itemnum, sample_func=sample_function, batch_size=args.batch_size, maxlen=args.maxlen, n_workers=1) sess.run(tf.global_variables_initializer()) # Set train dir now = datetime.now() TRAIN_FILES_PATH = os.path.join( MODEL_PATH, os.path.basename(args.dataset), '{}_{}'.format(args.train_dir, now.strftime("%m-%d-%Y-%H-%M-%S"))) # Allow saving of model MODEL_SAVE_PATH = os.path.join(TRAIN_FILES_PATH, 'model.ckpt') saver = tf.train.Saver() if args.test_model: if os.path.exists(args.test_model):
num_batch = len(train) / args.batch_size cc = 0.0 for u in train: cc += len(train[u]) print 'average sequence length: %.2f' % (cc / len(train)) f = open(os.path.join(args.dataset + '_' + args.train_dir, 'log.txt'), 'w') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(train, listnum, itemnum, creator_list_dict, batch_size=args.batch_size, maxlen=args.maxlen, n_workers=3) model = Model(creatorNum, itemnum, args) sess.run(tf.initialize_all_variables()) T = 0.0 t0 = time.time() threshold = 200 #try: for epoch in range(1, args.num_epochs + 1): for step in tqdm(range(num_batch),
def train_sasrec(n_args): if not os.path.exists("../../prediction_result/" + n_args.o_filename + ".csv"): if not os.path.isdir(n_args.dataset + '_' + n_args.train_dir): os.makedirs(n_args.dataset + '_' + n_args.train_dir) with open( os.path.join(n_args.dataset + '_' + n_args.train_dir, 'args.txt'), 'w') as f: f.write('\n'.join([ str(k) + ',' + str(v) for k, v in sorted(vars(n_args).items(), key=lambda x: x[0]) ])) f.close() dataset = data_partition(n_args.dataset, n_args.p_dataset, None) recall_s1 = Get_Recall_S1(n_args.recall_ds) # recall_v = Get_Recall_S1(n_args.recall_v) [ user_train, user_valid, user_test, user_pred, user_valid_, usernum, itemnum ] = dataset num_batch = math.ceil(len(user_train) / n_args.batch_size) cc = 0.0 for u in user_train: cc += len(user_train[u]) print('average sequence length: %.2f' % (cc / len(user_train))) f = open( os.path.join(n_args.dataset + '_' + n_args.train_dir, 'log.txt'), 'w') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(user_train, usernum, itemnum, batch_size=n_args.batch_size, maxlen=n_args.maxlen, n_workers=4) model = Model(usernum, itemnum, n_args) if not os.listdir("../user_data/model_data/"): sess.run(tf.global_variables_initializer()) T = 0.0 t0 = time.time() try: for epoch in range(1, n_args.num_epochs + 1): for step in tqdm(range(num_batch), total=num_batch, ncols=70, leave=False, unit='b'): u, seq, pos, neg = sampler.next_batch() auc, loss, _ = sess.run( [model.auc, model.loss, model.train_op], { model.u: u, model.input_seq: seq, model.pos: pos, model.neg: neg, model.is_training: True }) if epoch % 20 == 0: t1 = time.time() - t0 T += t1 print('Evaluating') t_test = evaluate(model, dataset, n_args, sess) t_valid = evaluate_valid(model, dataset, n_args, sess) print('') print( 'epoch:%d, time: %f(s), valid (NDCG@50: %.4f, HR@10: %.4f), test (NDCG@50: %.4f, HR@10: %.4f)' % (epoch, T, t_valid[0], t_valid[1], t_test[0], t_test[1])) f.write(str(t_valid) + ' ' + str(t_test) + '\n') f.flush() t0 = time.time() saver = tf.train.Saver() saver.save(sess, "../user_data/model_data/sasrec_model.ckpt") predict_result(model, dataset, recall_s1, n_args, sess, type='pred') # predict_result(model, dataset, recall_v, args, sess, type='valid') except: sampler.close() f.close() exit(1) else: saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, "../user_data/model_data/sasrec_model.ckpt") predict_result(model, dataset, recall_s1, n_args, sess, type='pred') # predict_result(model, dataset, recall_v, args, sess, type='valid') f.close() sampler.close() print("Done")
# get user-item matrix # make feature as dense matrix args = parse_args() Filename = args.dataset Filepath = 'Data/' + Filename dataset = Dataset.Dataset(Filepath) train, test = dataset.trainMatrix, dataset.testRatings textualfeatures, imagefeatures = dataset.textualfeatures, dataset.imagefeatures # print(type(features)) n_users, n_items = max(train.shape[0], test.shape[0]), max(train.shape[1], test.shape[1]) print(n_users, n_items) # create warp sampler sampler = WarpSampler(train, batch_size=args.batch_size, n_negative=args.num_neg, check_negative=True) # WITHOUT features # Train a user-item joint embedding, where the items a user likes will be pulled closer to this users. # Once the embedding is trained, the recommendations are made by finding the k-Nearest-Neighbor to each user. model = MAML( n_users, n_items, # enable feature projection imagefeatures=imagefeatures, textualfeatures=textualfeatures, embed_dim=64, batch_size=args.batch_size, # N_negatvie
'produce'] or item in user_validation[u][ 'consume'] or item in user_test[u][ 'consume'] or item in sample or item not in consumed_items: item = np.random.randint(0, itemnum) sample.add(item) sample_list.append(item) owner_list.append(owner[item]) return sample_list, owner_list sampler = WarpSampler(user_train, user_validation, user_test, owner, usernum, itemnum, consumed_items, batch_size=args.batch_size, n_workers=1) best_iter = 0 best_valid_mrr = 1e-6 prev_valid_mrr = 1e-6 f = open( 'out/%s_%s_%d_%d_%d_%g_%g.txt' % (args.dataset, args.alg, args.n_layers, args.emb_dim, args.n_neurons, args.lambda1, args.lambda2), 'w') ############# Architecture
dataset = data_partition('./data/movielens.txt') # [user_train, user_valid, user_test, user_num, item_num] = dataset [user_train, user_valid, user_test, user_num, item_num, item_count, cum_table] = dataset num_batch = len(user_train) // (batch_size) cc = 0.0 for u in user_train: cc += len(user_train[u]) print('average sequence length: {:.2f}'.format(cc / len(user_train))) sampler = WarpSampler(user_train, user_num, item_num, cum_table, batch_size=batch_size, max_len=max_len, n_workers=3) model, emb = build_model(max_len=max_len, input_dim=item_num + 1, embedding_dim=50, feed_forward_units=50, head_num=1, block_num=2, dropout_rate=0.2) optimizer = AdamOptimizer(0.001) tbcb = TensorBoard(log_dir='/logs', histogram_freq=1,
cc = 0.0 # for u in user_train: # cc += len(user_train[u]) # print 'average sequence length: %.2f' % (cc / len(user_train)) file_log = "log.txt_%s" % args.train_type f = open(os.path.join(args.folder_dataset_model, file_log), 'w') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(user_train, usernum, itemnum, batch_size=args.batch_size, maxlen=args.max_seq_len, n_workers=3) model = Model(usernum, itemnum, args) sess.run(tf.initialize_all_variables()) T = 0.0 t0 = time.time() best_epoch = 0. best_valid = [0., 0.] best_test = [0., 0.] for epoch in range(1, args.num_epochs + 1): epoch_loss = []
for line in open(item_file, 'r') } total_sample = sum( [int(line.split('\t')[2]) for line in open(item_file, 'r')]) test_sample = sum([ 1 for fn in glob.glob(os.path.join(test_triplet_path, '*')) for line in open(fn, 'r') ]) cluster = tf.train.ClusterSpec(cluster_config) num_batch = (total_sample - test_sample) / (len(cluster_config['worker']) * int(batch_size)) if task == 'ps': parameter_server(cluster, len(item2weight), int(embed_dim), int(idx), int(epoch), item_embedding_file) else: per_user = int( np.ceil(len(user2weight) * 1.0 / len(cluster_config['worker']))) user_chunk = list(chunks(range(len(user2weight)), per_user)) start, end = user_chunk[int(idx)][0], user_chunk[int(idx)][-1] sampler = WarpSampler(pos_pair_path, batch_size=int(batch_size), n_workers=int(n_workers), item2weight=item2weight, negative_num=int(negative_num), start=start, end=end) evaluator = Evaluator(test_triplet_path, start, end) worker(cluster, len(item2weight), int(embed_dim), int(idx), int(epoch), float(alpha), float(learning_rate), sampler, evaluator, num_batch, end - start + 1)
# print 'itemnum: %d' % (itemnum) # my code num_batch = len(user_train) / args.batch_size cc = 0.0 for u in user_train: cc += len(user_train[u]) print 'average sequence length: %.2f' % (cc / len(user_train)) f = open(os.path.join(args.dataset + '_' + args.train_dir, 'log.txt'), 'w') config = tf.ConfigProto() # configure the session config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU, increase GPU utilization config.allow_soft_placement = True # allow TensorFlow to automatically choose an existing and supported device to run the operations sess = tf.Session(config=config) # Driver for Graph execution sampler = WarpSampler(user_train, usernum, itemnum, batch_size=args.batch_size, maxlen=args.maxlen, n_workers=3) text_emb = np.load( 'data/reviews_emb.npy') # my code, loading the text embedding of item print('The loaded embedding type is {}'.format(text_emb.dtype) ) # my code, show loaded embedding's data type # text_emb = np.random.rand(itemnum+1, 300) # my code, for text embeddings # text_emb = tf.random.uniform(shape=[itemnum+1, 300], minval=0, maxval=1, dtype=tf.float32, seed=10) # my code model = Model(usernum, itemnum, args) # sess.run(tf.global_variables_initializer) # my code sess.run(tf.initialize_all_variables()) T = 0.0 t0 = time.time()
print("\nThere are {0} users {1} items \n".format(usernum, itemnum)) print("Average sequence length: {0}\n".format(cc / len(user_train))) print("Maximum length of sequence: {0}\n".format(max_len)) f = open( os.path.join(args.dataset + '_' + args.train_dir, 'log_{}.txt'.format(timestamp)), 'w') config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) sampler = WarpSampler(user_train, usernum, itemnum, batch_size=args.batch_size, maxlen=args.maxlen, threshold_user=args.threshold_user, threshold_item=args.threshold_item, n_workers=3) model = Model(usernum, itemnum, args) sess.run(tf.global_variables_initializer()) T = 0.0 t_test = evaluate(model, dataset, args, sess) t_valid = evaluate_valid(model, dataset, args, sess) print_result(0, 0.0, t_valid, t_test) print_result(0, 0.0, t_valid, t_test, f=f) # print("[0, 0.0, {0}, {1}, {2}, {3}],".format(t_valid[0], t_valid[1], t_test[0], t_test[1])) t0 = time.time()
# negative and positive matrix have the same shape n_users, n_items = user_item_matrix.shape print(n_users, n_items) # make feature as dense matrix dense_features = features.toarray() + 1E-10 # get train/valid/test user-item matrices train, valid, test = split_data(user_item_matrix) train_exp_neg, valid_exp_neg, test_exp_neg = split_data( user_item_exp_neg_matrix) # create warp sampler sampler = WarpSampler(train, train_exp_neg, batch_size=BATCH_SIZE, n_negative=N_NEGATIVE, check_negative=True) # WITHOUT features # Train a user-item joint embedding, where the items a user likes will be pulled closer to this users. # Once the embedding is trained, the recommendations are made by finding the k-Nearest-Neighbor to each user. #@sandro Uncommented due to being not needed # model = CML(n_users, # n_items, # # set features to None to disable feature projection # features=None,x # # size of embedding # embed_dim=EMBED_DIM, # # the size of hinge loss margin.