def __init__(self):
start_time = time.time()
model_parameter_ins = model_parameter()
experiment_name = model_parameter_ins.flags.FLAGS.experiment_name
self.FLAGS = model_parameter_ins.get_parameter(experiment_name).FLAGS
log_ins = create_log(type=self.FLAGS.type,
experiment_type=self.FLAGS.experiment_type,
version=self.FLAGS.version)
self.logger = log_ins.logger
self.logger.info("hello world the experiment begin")
# logger.info("The model parameter is :" + str(self.FLAGS._parse_flags()))
if self.FLAGS.type == "yoochoose":
get_origin_data_ins = Get_yoochoose_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "movielen":
get_origin_data_ins = Get_movie_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
if self.FLAGS.type == "tmall":
get_origin_data_ins = Get_tmall_data(FLAGS=self.FLAGS)
elif self.FLAGS.type == "movie_tv":
get_origin_data_ins = Get_amazon_data_movie_tv(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "elec":
get_origin_data_ins = Get_amazon_data_elec(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "music":
get_origin_data_ins = Get_amazon_data_music(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == 'taobaoapp':
get_origin_data_ins = Get_taobaoapp_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
#get_train_test_ins = Get_train_test(FLAGS=self.FLAGS,origin_data=get_origin_data_ins.origin_data)
prepare_data_behavior_ins = prepare_data_base(
self.FLAGS, get_origin_data_ins.origin_data)
self.train_set, self.test_set = prepare_data_behavior_ins.get_train_test(
)
#fetch part of test_data
#if len(self.train_set) > 2000000:
#self.test_set = random.sample(self.train_set,2000000)
#self.test_set = self.test_set.sample(3500)
self.logger.info('DataHandle Process.\tCost time: %.2fs' %
(time.time() - start_time))
start_time = time.time()
self.emb = Behavior_embedding_time_aware_attention(
is_training=self.FLAGS.is_training,
user_count=prepare_data_behavior_ins.user_count,
item_count=prepare_data_behavior_ins.item_count,
category_count=prepare_data_behavior_ins.category_count,
max_length_seq=self.FLAGS.length_of_user_history)
self.logger.info('Get Train Test Data Process.\tCost time: %.2fs' %
(time.time() - start_time))
self.item_category_dic = prepare_data_behavior_ins.item_category_dic
self.global_step = 0
self.one_epoch_step = 0
self.now_epoch = 0
class Train_main_process:
def __init__(self):
start_time = time.time()
model_parameter_ins = model_parameter()
experiment_name = model_parameter_ins.flags.FLAGS.experiment_name
self.FLAGS = model_parameter_ins.get_parameter(experiment_name).FLAGS
log_ins = create_log(type=self.FLAGS.type,
experiment_type=self.FLAGS.experiment_type,
version=self.FLAGS.version)
self.logger = log_ins.logger
self.logger.info("hello world the experiment begin")
# logger.info("The model parameter is :" + str(self.FLAGS._parse_flags()))
if self.FLAGS.type == "yoochoose":
get_origin_data_ins = Get_yoochoose_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "movielen":
get_origin_data_ins = Get_movie_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
if self.FLAGS.type == "tmall":
get_origin_data_ins = Get_tmall_data(FLAGS=self.FLAGS)
elif self.FLAGS.type == "movie_tv":
get_origin_data_ins = Get_amazon_data_movie_tv(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "elec":
get_origin_data_ins = Get_amazon_data_elec(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == "music":
get_origin_data_ins = Get_amazon_data_music(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
elif self.FLAGS.type == 'taobaoapp':
get_origin_data_ins = Get_taobaoapp_data(FLAGS=self.FLAGS)
get_origin_data_ins.getDataStatistics()
#get_train_test_ins = Get_train_test(FLAGS=self.FLAGS,origin_data=get_origin_data_ins.origin_data)
if self.FLAGS.type != 'hawkes':
prepare_data_behavior_ins = prepare_data_base(
self.FLAGS, get_origin_data_ins.origin_data)
self.train_set, self.test_set = prepare_data_behavior_ins.get_train_test(
)
else:
loder = DataLoader()
self.train_set, self.test_set = loder.load_save_datasets()
#fetch part of test_data
#if len(self.train_set) > 2000000:
#self.test_set = random.sample(self.train_set,2000000)
#self.test_set = self.test_set.sample(3500)
self.logger.info('DataHandle Process.\tCost time: %.2fs' %
(time.time() - start_time))
start_time = time.time()
if self.FLAGS.type != 'hawkes':
self.emb = Behavior_embedding_time_aware_attention(
is_training=self.FLAGS.is_training,
user_count=prepare_data_behavior_ins.user_count,
item_count=prepare_data_behavior_ins.item_count,
category_count=prepare_data_behavior_ins.category_count,
max_length_seq=self.FLAGS.length_of_user_history)
else:
self.emb = Behavior_embedding_time_aware_attention(
is_training=self.FLAGS.is_training,
user_count=1,
item_count=5,
category_count=5,
max_length_seq=self.FLAGS.length_of_user_history)
self.logger.info('Get Train Test Data Process.\tCost time: %.2fs' %
(time.time() - start_time))
if self.FLAGS.type != 'hawkes':
self.item_category_dic = prepare_data_behavior_ins.item_category_dic
self.global_step = 0
self.one_epoch_step = 0
self.now_epoch = 0
'''
def _eval_auc(self, test_set):
auc_input = []
auc_input = np.reshape(auc_input,(-1,2))
for _, uij in DataInputTest(test_set, FLAGS.test_batch_size):
#auc_sum += model.eval(sess, uij) * len(uij[0])
auc_input = np.concatenate((auc_input,self.model.eval_test(self.sess,uij)))
#test_auc = auc_sum / len(test_set)
test_auc = roc_auc_score(auc_input[:,1],auc_input[:,0])
self.model.eval_writer.add_summary(
summary=tf.Summary(
value=[tf.Summary.Value(tag='New Eval AUC', simple_value=test_auc)]),
global_step=self.model.global_step.eval())
return test_auc
'''
def train(self):
start_time = time.time()
# Config GPU options
if self.FLAGS.per_process_gpu_memory_fraction == 0.0:
gpu_options = tf.GPUOptions(allow_growth=True)
elif self.FLAGS.per_process_gpu_memory_fraction == 1.0:
gpu_options = tf.GPUOptions()
else:
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=self.
FLAGS.per_process_gpu_memory_fraction,
allow_growth=True)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ['CUDA_VISIBLE_DEVICES'] = self.FLAGS.cuda_visible_devices
self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
if not tf.test.gpu_device_name():
self.logger.warning("No GPU is found")
else:
self.logger.info(tf.test.gpu_device_name())
global_step_lr = tf.Variable(0, trainable=False)
lr1 = tf.train.exponential_decay(
learning_rate=self.FLAGS.learning_rate,
global_step=global_step_lr,
decay_steps=100,
decay_rate=0.99,
staircase=True)
lr2 = tf.train.exponential_decay(learning_rate=0.001,
global_step=global_step_lr,
decay_steps=100,
decay_rate=self.FLAGS.decay_rate,
staircase=True)
with self.sess.as_default():
# Create a new model or reload existing checkpoint
if self.FLAGS.experiment_type == "Vallina_Gru4Rec":
self.model = Vallina_Gru4Rec(self.FLAGS, self.emb, self.sess)
#1 baseline for all models
if self.FLAGS.experiment_type == "Gru4Rec":
self.model = Gru4Rec(self.FLAGS, self.emb, self.sess)
#2
elif self.FLAGS.experiment_type == "T_SeqRec":
self.model = T_SeqRec(self.FLAGS, self.emb, self.sess)
#3
elif self.FLAGS.experiment_type == "NARM":
self.model = NARM(self.FLAGS, self.emb, self.sess)
#4
elif self.FLAGS.experiment_type == "NARM+":
self.model = NARM_time_att(self.FLAGS, self.emb, self.sess)
#5
elif self.FLAGS.experiment_type == "NARM++":
self.model = NARM_time_att_time_rnn(self.FLAGS, self.emb,
self.sess)
#6
elif self.FLAGS.experiment_type == "LSTUR":
self.model = LSTUR(self.FLAGS, self.emb, self.sess)
#7
elif self.FLAGS.experiment_type == "STAMP":
self.model = STAMP(self.FLAGS, self.emb, self.sess)
#8 the proposed model
elif self.FLAGS.experiment_type == 'MTAM':
self.model = MTAM(self.FLAGS, self.emb, self.sess)
# 9
elif self.FLAGS.experiment_type == "MTAM_no_time_aware_rnn":
self.model = MTAM_no_time_aware_rnn(self.FLAGS, self.emb,
self.sess)
# 10
elif self.FLAGS.experiment_type == "MTAM_no_time_aware_att":
self.model = MTAM_no_time_aware_att(self.FLAGS, self.emb,
self.sess)
#11
elif self.FLAGS.experiment_type == 'MTAM_via_T_GRU':
self.model = MTAM_via_T_GRU(self.FLAGS, self.emb, self.sess)
# 12
elif self.FLAGS.experiment_type == 'MTAM_via_rnn':
self.model = MTAM_via_rnn(self.FLAGS, self.emb, self.sess)
#13 the proposed model
elif self.FLAGS.experiment_type == 'T_GRU':
self.model = MTAM_only_time_aware_RNN(self.FLAGS, self.emb,
self.sess)
# 14 the proposed model
elif self.FLAGS.experiment_type == 'SASrec':
self.model = Self_Attention_Model(self.FLAGS, self.emb,
self.sess)
# 15 the proposed model
elif self.FLAGS.experiment_type == 'Time_Aware_Self_Attention_Model':
self.model = Time_Aware_Self_Attention_Model(
self.FLAGS, self.emb, self.sess)
elif self.FLAGS.experiment_type == 'Ti_Self_Attention_Model':
self.model = Ti_Self_Attention_Model(self.FLAGS, self.emb,
self.sess)
# 16 the proposed model
elif self.FLAGS.experiment_type == 'bpr':
self.model = BPRMF(self.FLAGS, self.emb, self.sess)
# 17 the proposed model
elif self.FLAGS.experiment_type == "MTAM_with_T_SeqRec":
self.model = MTAM_with_T_SeqRec(self.FLAGS, self.emb,
self.sess)
self.logger.info('Init finish.\tCost time: %.2fs' %
(time.time() - start_time))
#AUC暂时不看
# test_auc = self.model.metrics(sess=self.sess,
# batch_data=self.test_set,
# global_step=self.global_step,
# name='test auc')
# Eval init AUC
# self.logger.info('Init AUC: %.4f' % test_auc)
test_start = time.time()
self.hr_1, self.ndcg_1, self.hr_5, self.ndcg_5, self.hr_10, self.ndcg_10, self.hr_30, self.ndcg_30, self.hr_50, self.ndcg_50 = \
0,0,0,0,0,0,0,0,0,0
self.best_result_hr = []
self.best_result_ndcg = []
def eval_topk():
sum_hr_1, sum_ndcg_1, sum_hr_5, sum_ndcg_5, sum_hr_10, sum_ndcg_10, sum_hr_30, sum_ndcg_30, sum_hr_50, sum_ndcg_50 = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
result_list_hr_all = []
result_list_ndcg_all = []
max_step = 0
for step_i, batch_data in DataInput(
self.test_set, self.FLAGS.test_batch_size):
max_step = 1 + max_step
if self.FLAGS.experiment_type == "NARM" or \
self.FLAGS.experiment_type == "NARM+" or \
self.FLAGS.experiment_type == "NARM++": # or \
#self.FLAGS.experiment_type == "MTAM" :
hr_1, ndcg_1, hr_5, ndcg_5,result_list_hr, result_list_ndcg= \
self.model.metrics_topK_concat(sess=self.sess,
batch_data=batch_data,
global_step=self.global_step,
topk=self.FLAGS.top_k)
else:
hr_1, ndcg_1, hr_5, ndcg_5,result_list_hr, result_list_ndcg = \
self.model.metrics_topK(sess=self.sess,
batch_data=batch_data,
global_step=self.global_step,
topk=self.FLAGS.top_k)
sum_hr_1 = sum_hr_1 + hr_1
sum_ndcg_1 = sum_ndcg_1 + ndcg_1
sum_hr_5 = sum_hr_5 + hr_5
sum_ndcg_5 = sum_ndcg_5 + ndcg_5
result_list_hr_all = result_list_hr_all + result_list_hr
result_list_ndcg_all = result_list_ndcg_all + result_list_ndcg
sum_hr_1 /= max_step
sum_ndcg_1 /= max_step
sum_hr_5 /= max_step
sum_ndcg_5 /= max_step
if sum_hr_1 > self.hr_1 and sum_ndcg_1 > self.ndcg_1:
self.hr_1, self.ndcg_1 = sum_hr_1, sum_ndcg_1
if sum_hr_5 > self.hr_5 and sum_ndcg_5 > self.ndcg_5:
self.hr_5, self.ndcg_5 = sum_hr_5, sum_ndcg_5
def summery(k, hr, ndcg):
tag_recall = 'recall@' + str(k)
tag_ndcg = 'ndgc@' + str(k)
summary_recall_rate = tf.Summary(value=[
tf.Summary.Value(tag=tag_recall, simple_value=hr)
])
self.model.train_writer.add_summary(
summary_recall_rate, global_step=self.global_step)
summary_avg_ndcg = tf.Summary(value=[
tf.Summary.Value(tag=tag_ndcg, simple_value=ndcg)
])
self.model.train_writer.add_summary(
summary_avg_ndcg, global_step=self.global_step)
self.logger.info(
'Test recall rate @ %d : %.4f ndcg @ %d: %.4f' %
(k, hr, k, ndcg))
summery(1, sum_hr_1, sum_ndcg_1)
summery(5, sum_hr_5, sum_ndcg_5)
eval_topk()
self.logger.info('End test. \tTest Cost time: %.2fs' %
(time.time() - test_start))
# Start training
self.logger.info(
'Training....\tmax_epochs:%d\tepoch_size:%d' %
(self.FLAGS.max_epochs, self.FLAGS.train_batch_size))
start_time, avg_loss, self.best_auc, self.best_recall, self.best_ndcg = time.time(
), 0.0, 0.0, 0.0, 0.0
for epoch in range(self.FLAGS.max_epochs):
#if epoch > 2:
#lr = lr/1.5
random.shuffle(self.train_set)
self.logger.info('tain_set:%d' % len(self.train_set))
epoch_start_time = time.time()
learning_rate = self.FLAGS.learning_rate
for step_i, train_batch_data in DataInput(
self.train_set, self.FLAGS.train_batch_size):
try:
#print(self.sess.run(global_step_lr))
if learning_rate > 0.001:
learning_rate = self.sess.run(
lr1,
feed_dict={global_step_lr: self.global_step})
else:
learning_rate = self.sess.run(
lr2,
feed_dict={global_step_lr: self.global_step})
#print(learning_rate)
add_summary = bool(self.global_step %
self.FLAGS.display_freq == 0)
step_loss, merge = self.model.train(
self.sess, train_batch_data, learning_rate,
add_summary, self.global_step, epoch)
self.model.train_writer.add_summary(
merge, self.global_step)
avg_loss = avg_loss + step_loss
self.global_step = self.global_step + 1
self.one_epoch_step = self.one_epoch_step + 1
#evaluate for eval steps
if self.global_step % self.FLAGS.eval_freq == 0:
print(learning_rate)
self.logger.info("Epoch step is " +
str(self.one_epoch_step))
self.logger.info("Global step is " +
str(self.global_step))
self.logger.info("Train_loss is " +
str(avg_loss /
self.FLAGS.eval_freq))
# train_auc = self.model.metrics(sess=self.sess, batch_data=train_batch_data,
# global_step=self.global_step,name='train auc')
# self.logger.info('Batch Train AUC: %.4f' % train_auc)
# self.test_auc = self.model.metrics(sess=self.sess, batch_data=self.test_set,
# global_step=self.global_step,name='test auc')
# self.logger.info('Test AUC: %.4f' % self.test_auc)
eval_topk()
avg_loss = 0
self.save_model()
if self.FLAGS.draw_pic == True:
self.save_fig()
except Exception as e:
self.logger.info("Error！！！！！！！！！！！！")
self.logger.info(e)
self.logger.info('one epoch Cost time: %.2f' %
(time.time() - epoch_start_time))
self.logger.info("Epoch step is " + str(self.one_epoch_step))
self.logger.info("Global step is " + str(self.global_step))
self.logger.info("Train_loss is " + str(step_loss))
eval_topk()
with open('best_result_hr_' + self.FLAGS.version, 'w+') as f:
f.write(str(self.best_result_hr))
with open('best_result_ndcg' + self.FLAGS.version, 'w+') as f:
f.write(str(self.best_result_ndcg))
self.logger.info('Max recall rate @ 1: %.4f ndcg @ 1: %.4f' %
(self.hr_1, self.ndcg_1))
self.logger.info('Max recall rate @ 5: %.4f ndcg @ 5: %.4f' %
(self.hr_5, self.ndcg_5))
self.logger.info(
'Max recall rate @ 10: %.4f ndcg @ 10: %.4f' %
(self.hr_10, self.ndcg_10))
self.logger.info(
'Max recall rate @ 30: %.4f ndcg @ 30: %.4f' %
(self.hr_30, self.ndcg_30))
self.logger.info(
'Max recall rate @ 50: %.4f ndcg @ 50: %.4f' %
(self.hr_50, self.ndcg_50))
self.one_epoch_step = 0
#if self.global_step > 1000:
#lr = lr / 2
#if lr < 0.0005:
#lr = lr * 0.99
#elif self.FLAGS.type == "tmall":
#lr = lr * 0.5
#else:
#lr = lr * 0.98
self.logger.info('Epoch %d DONE\tCost time: %.2f' %
(self.now_epoch, time.time() - start_time))
self.now_epoch = self.now_epoch + 1
self.one_epoch_step = 0
self.model.save(self.sess, self.global_step)
self.logger.info('best test_auc: ' + str(self.best_auc))
self.logger.info('best recall: ' + str(self.best_recall))
self.logger.info('Finished')
#judge to save model
#three result for evaluating model: auc ndcg recall
def save_model(self):
# avg_loss / self.FLAGS.eval_freq, test_auc,test_auc_new))
# result.append((self.model.global_epoch_step.eval(), model.global_step.eval(), avg_loss / FLAGS.eval_freq, _eval(sess, test_set, model), _eval_auc(sess, test_set, model)))avg_loss = 0.0
# only store good model
is_save_model = False
#for bsbe
'''
if self.FLAGS.experiment_type == "bsbe" or self.FLAGS.experiment_type == "bpr":
if (self.test_auc > 0.85 and self.test_auc - self.best_auc > 0.01):
self.best_auc = self.test_auc
is_save_model = True
#recall for istsbp
elif self.FLAGS.experiment_type == "istsbp" or self.FLAGS.experiment_type == "pistrec":
if self.recall_rate > 0.15 and self.recall_rate > self.best_recall:
self.best_recall = self.recall_rate
is_save_model =True
'''
if self.global_step % 50000 == 0:
is_save_model = True
if is_save_model == True:
self.model.save(self.sess, self.global_step)
def save_fig(self):
# save fig
if self.global_step % (self.FLAGS.eval_freq * 1) == 0:
input_dic = self.emb.make_feed_dic(batch_data=self.test_set[:100])
if self.FLAGS.experiment_type == "istsbp" or \
self.FLAGS.experiment_type == "bsbe":
input_dic[self.model.now_bacth_data_size] = len(
self.test_set[:100])
behavior = self.sess.run(
self.model.user_history_embedding_result_dense, input_dic)
usr_h_fig, short_term_intent_fig, attention_result_fig, item_emb_lookup_table_fig = \
self.sess.run([self.model.user_h, self.model.short_term_intent,
self.model.attention_result,
self.emb.item_emb_lookup_table], input_dic)
# draw picture
generate_pic_class_ins = generate_pic_class(
init=False,
user_h=usr_h_fig,
short_term_intent=short_term_intent_fig,
attention_result=attention_result_fig,
item_table=item_emb_lookup_table_fig,
item_category_dic=self.item_category_dic)
generate_pic_class_ins.draw_picure(
type=self.FLAGS.type,
experiment_type=self.FLAGS.experiment_type,
version=self.FLAGS.version,
global_step=self.global_step)
self.logger.info("save fig finish!!!")