def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=True): super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__init__(n_uid, n_mid, n_cat,EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE,use_negsampling) with tf.name_scope('rnn_1'): rnn_outputs,_ = dynamic_rnn(GRUCell(HIDDEN_SIZE),inputs = self.item_his_eb,sequence_length=self.seq_len_ph,dtype=tf.float32,scope='gru1') tf.summary.histogram("GRU_outputs",rnn_outputs) aux_loss_1 = self.auxiliary_loss(rnn_outputs[:,:-1,:],self.item_his_eb[:,1:,:],self.noclk_item_his_eb[:,1:,:],self.mask[:,1:],stag="gru") self.aux_loss = aux_loss_1 with tf.name_scope('Attention_layer_1'): att_outputs,alphas = din_fcn_attention(self.item_eb,rnn_outputs,ATTENTION_SIZE,self.mask, softmax_stag=1,stag='1_1',mode='LIST',return_alphas=True) tf.summary.histogram('alpha_outputs',alphas) with tf.name_scope('rnn_2'): rnn_outputs2,final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE),inputs=rnn_outputs, att_scores=tf.expand_dims(alphas,-1), sequence_length = self.seq_len_ph,dtype=tf.float32, scope="gru2" ) tf.summary.histogram("GRU2_Final_State",final_state2) inp = tf.concat([self.uid_batch_embedded,self.item_eb,self.item_his_eb_sum,self.item_eb * self.item_his_eb_sum,final_state2],1) self.build_fcn_net(inp,use_dice=True)
def build_tf_net(self, datas, is_train=True): super(Model_DIEN,self).build_tf_net(datas, is_train) # RNN layer(-s) # GRU of interest extractor layer with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(self.hidden_size, kernel_initializer=get_tf_initializer()), inputs=self.item_his_eb, sequence_length=self.tensors.seq_len, dtype=tf.float32, scope="gru1") aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.tensors.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # Attention layer # Attention of interest evolving layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, self.attention_size, self.tensors.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) # AUGRU of interest evolving layer with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(self.hidden_size, kernel_initializer=get_tf_initializer()), inputs=rnn_outputs, att_scores=tf.expand_dims( alphas, -1), sequence_length=self.tensors.seq_len, dtype=tf.float32, scope="gru2") inp = tf.concat([self.tensors.uid, self.item_eb, final_state2, self.item_his_eb_sum], 1) # after concat and flatten(?), put into Model.fcn self.build_fcn_net(inp, use_dice=True)
def __init__(self, n, n_query, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_DIN_V2_Gru_Gru_att, self).__init__(n, n_query, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) with tf.name_scope('rnn_2'): rnn_outputs2, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=rnn_outputs, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_outputs', rnn_outputs2) # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs2, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) att_fea = tf.reduce_sum(att_outputs, 1) tf.summary.histogram('att_fea', att_fea) inp = tf.concat([self.query_eb, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, att_fea], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=True): super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # RNN layer(-s) 第一层GRU 将用户行为历史的item embedding输入到dynamic rnn中,同时计算辅助loss with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) # 辅助loss的计算其实是一个二分类模型,代码如下: aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores = tf.expand_dims(alphas, -1), #计算兴趣的进化过程 sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2], 1) #最后我们通过一个多层神经网络,得到最终的ctr预估值 self.build_fcn_net(inp, use_dice=True)
def __init__(self, n, n_query,EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_DIN_V2_Gru_Vec_attGru, self).__init__(n, n_query, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores = tf.expand_dims(alphas, -1), sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) #inp = tf.concat([self.uid_batch_embedded, self.item_eb, final_state2, self.item_his_eb_sum], 1) inp = tf.concat([self.query_eb, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, feature_size, eb_dim, hidden_size, max_len_item, max_len_user, item_part_fnum, user_part_fnum, use_hist_u, use_hist_i, emb_initializer): super(DIEN, self).__init__(feature_size, eb_dim, hidden_size, max_len_item, max_len_user, item_part_fnum, user_part_fnum, use_hist_u, use_hist_i, emb_initializer) # attention RNN layer: Item with tf.name_scope('item_rnn_1'): item_part_output, _ = tf.nn.dynamic_rnn(GRUCell(hidden_size), inputs=self.item_part_emb, sequence_length=self.item_len_ph, dtype=tf.float32, scope='gru1') with tf.name_scope('item_attention'): _, _, item_score = self.attention(item_part_output, item_part_output, self.target_item, self.item_mask) with tf.name_scope('item_rnn_2'): _, item_part = dynamic_rnn(VecAttGRUCell(hidden_size), inputs=item_part_output, att_scores = tf.expand_dims(item_score, -1), sequence_length=self.item_len_ph, dtype=tf.float32, scope="argru1") # attention RNN layer: User with tf.name_scope('user_rnn_1'): user_part_output, _ = tf.nn.dynamic_rnn(GRUCell(hidden_size), inputs=self.user_part_emb, sequence_length=self.user_len_ph, dtype=tf.float32, scope='gru2') with tf.name_scope('user_attention'): _, _, user_score = self.attention(user_part_output, user_part_output, self.target_user, self.user_mask) with tf.name_scope('user_rnn_2'): _, user_part = dynamic_rnn(VecAttGRUCell(hidden_size), inputs=user_part_output, att_scores = tf.expand_dims(user_score, -1), sequence_length=self.user_len_ph, dtype=tf.float32, scope="argru2") if use_hist_i and use_hist_u: inp = tf.concat([item_part, user_part], axis=1) elif use_hist_i and not use_hist_u: inp = item_part elif not use_hist_i and use_hist_u: inp = user_part # fully connected layer self.build_fc_net(inp) self.build_loss()
def __init__(self, n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN=400, use_negsample=False): super(Model_DIEN, self).__init__(n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN, use_negsample, Flag="DIEN") with tf.name_scope('rnn_1'): self.sequence_length = tf.Variable([SEQ_LEN] * BATCH_SIZE) rnn_outputs, _ = dynamic_rnn(GRUCell(2*EMBEDDING_DIM), inputs=self.item_his_eb, sequence_length=self.sequence_length, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) if use_negsample: aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.neg_his_eb[:, 1:, :], self.mask[:, 1:], stag = "bigru_0") self.aux_loss = aux_loss_1 # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_attention(self.item_eb, rnn_outputs, HIDDEN_SIZE, mask=self.mask, mode="LIST", return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores = tf.expand_dims(alphas, -1), sequence_length=self.sequence_length, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([self.item_eb, final_state2, self.item_his_eb_sum, self.item_eb*self.item_his_eb_sum], 1) self.build_fcn_net(inp, use_dice=False)
def build_tf_net(self, datas, is_train=True): super(Model_DIEN, self).build_tf_net(datas, is_train) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(self.hidden_size, kernel_initializer=get_tf_initializer()), inputs=self.item_his_eb, sequence_length=self.tensors.seq_len, dtype=tf.float32, scope="gru1") aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.tensors.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, self.attention_size, self.tensors.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(self.hidden_size, kernel_initializer=get_tf_initializer()), inputs=rnn_outputs, att_scores=tf.expand_dims( alphas, -1), sequence_length=self.tensors.seq_len, dtype=tf.float32, scope="gru2") inp = tf.concat([self.tensors.uid, self.item_eb, final_state2, self.item_his_eb_sum], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=True, use_others=False): super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling, use_others) with self.grath.as_default(): # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores=tf.expand_dims(alphas, -1), sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([ self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2 ], 1) if self.use_others: inp = tf.concat([inp] + list(self.other_inputs()), 1) self.build_fcn_net(inp, use_dice=True)
def __call__(self, features, labels): super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__call__(features, labels) def dtype_getter(getter, name, dtype=None, *args, **kwargs): var = getter(name, dtype=self.model_dtype, *args, **kwargs) return var with tf.variable_scope("dien", custom_getter=dtype_getter, dtype=self.model_dtype): # RNN layer(-s) with tf.name_scope('rnn_1'): res_1 = GRUCell(self.HIDDEN_SIZE) #res_2 = CudnnGRU(self.HIDDEN_SIZE) rnn_outputs, _ = dynamic_rnn(res_1, inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=self.model_dtype, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, self.ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True, forCnn=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( VecAttGRUCell(self.HIDDEN_SIZE), inputs=rnn_outputs, att_scores=tf.expand_dims(alphas, -1), sequence_length=self.seq_len_ph, dtype=self.model_dtype, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([ self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2 ], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN=256): super(Model_ARNN, self).__init__(n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN, Flag="ARNN") with tf.name_scope('rnn_1'): self.sequence_length = tf.Variable([SEQ_LEN] * BATCH_SIZE) rnn_outputs, final_state1 = dynamic_rnn( GRUCell(2 * EMBEDDING_DIM), inputs=self.item_his_eb, sequence_length=self.sequence_length, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) # Attention layer with tf.name_scope('Attention_layer_1'): att_gru = din_attention(self.item_eb, rnn_outputs, HIDDEN_SIZE, self.mask) att_gru = tf.reduce_sum(att_gru, 1) inp = tf.concat( [self.item_eb, self.item_his_eb_sum, final_state1, att_gru], -1) self.build_fcn_net(inp, use_dice=False)
def __init__(self, feature_size, eb_dim, hidden_size, max_time_len, user_fnum, item_fnum, emb_initializer): super(DIEN, self).__init__(feature_size, eb_dim, hidden_size, max_time_len, user_fnum, item_fnum, emb_initializer) mask = tf.sequence_mask(self.user_seq_length_ph, max_time_len, dtype=tf.float32) # attention RNN layer with tf.name_scope('rnn_1'): user_seq_ht, _ = tf.nn.dynamic_rnn( GRUCell(hidden_size), inputs=self.user_seq, sequence_length=self.user_seq_length_ph, dtype=tf.float32, scope='gru1') with tf.name_scope('attention'): atten_score, _, = self.attention(user_seq_ht, user_seq_ht, self.target_item, mask) with tf.name_scope('rnn_2'): _, seq_rep = dynamic_rnn(VecAttGRUCell(hidden_size), inputs=user_seq_ht, att_scores=atten_score, sequence_length=self.user_seq_length_ph, dtype=tf.float32, scope="argru1") inp = tf.concat([seq_rep, self.target_user, self.target_item], axis=1) # fully connected layer self.build_fc_net(inp) self.build_logloss()
def __init__(self, n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN=256): super(Model_GRU4REC, self).__init__(n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN, Flag="GRU4REC") with tf.name_scope('rnn_1'): self.sequence_length = tf.Variable([SEQ_LEN] * BATCH_SIZE) rnn_outputs, final_state1 = dynamic_rnn( GRUCell(2 * EMBEDDING_DIM), inputs=self.item_his_eb, sequence_length=self.sequence_length, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) inp = tf.concat([self.item_eb, self.item_his_eb_sum, final_state1], 1) self.build_fcn_net(inp, use_dice=False)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_T_SeqRec, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) item_history_embedding_new = tf.concat([ self.item_history_embedding, tf.expand_dims(self.timelast_history, -1) ], -1) item_history_embedding_new = tf.concat([ item_history_embedding_new, tf.expand_dims(self.timenow_history, -1) ], -1) # RNN layer(1) with tf.name_scope('rnn'): rnn_outputs, final_state = dynamic_rnn( Time4LSTMCell(HIDDEN_SIZE), inputs=item_history_embedding_new, sequence_length=self.sequence_length, dtype=tf.float32, scope="time4lstm") tf.summary.histogram('LSTM_outputs', rnn_outputs) last_inps = tf.concat([self.target_item_embedding, final_state[1]], 1) self.fcn_net(last_inps, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_CARNN, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) self.item_his_eb = tf.concat( [self.item_his_eb, tf.expand_dims(self.time_his_batch_ph, -1)], -1) # RNN layer(-s) - 1 with tf.name_scope('rnn_1'): rnn_outputs1, final_state1 = dynamic_rnn( CARNNCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="carnn1") tf.summary.histogram('CARNN_outputs1', rnn_outputs1) inp = tf.concat([final_state1, self.item_eb], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_T_SeqRec, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) item_his_eb_new = tf.concat([ self.item_his_eb, tf.expand_dims(self.time_last_his_batch_ph, -1) ], -1) item_his_eb_new = tf.concat( [item_his_eb_new, tf.expand_dims(self.time_now_his_batch_ph, -1)], -1) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, final_state1 = dynamic_rnn( Time4LSTMCell(HIDDEN_SIZE), inputs=item_his_eb_new, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="lstm1") tf.summary.histogram('LSTM_outputs', rnn_outputs) inp = tf.concat([self.item_eb, final_state1[1]], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_NARM, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # RNN layer(-s) - 1 with tf.name_scope('rnn_1'): rnn_outputs1, final_state1 = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="lstm1") tf.summary.histogram('LSTM_outputs1', rnn_outputs1) # RNN layer(-s) - 2 with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="lstm2") tf.summary.histogram('LSTM_outputs2', rnn_outputs2) # Attention layer with tf.name_scope('Attention_layer'): att_outputs, alphas = din_fcn_attention(final_state1[1], rnn_outputs2, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) att_fea = tf.reduce_sum(att_outputs, 1) inp = tf.concat([final_state1[1], att_fea, self.item_eb], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_SLi_Rec_Fixed, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # Attention layer 1 with tf.name_scope('Attention_layer_1'): att_outputs1, alphas1 = attention_HAN( self.item_his_eb, attention_size=ATTENTION_SIZE, return_alphas=True) att_fea1 = tf.reduce_sum(att_outputs1, 1) tf.summary.histogram('att_fea1', att_fea1) item_his_eb_new = tf.concat([ self.item_his_eb, tf.expand_dims(self.time_last_his_batch_ph, -1) ], -1) item_his_eb_new = tf.concat( [item_his_eb_new, tf.expand_dims(self.time_now_his_batch_ph, -1)], -1) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, final_state1 = dynamic_rnn( Time4LSTMCell(HIDDEN_SIZE), inputs=item_his_eb_new, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="lstm1") tf.summary.histogram('LSTM_outputs', rnn_outputs) # Attention layer 2 with tf.name_scope('Attention_layer_2'): att_outputs2, alphas2 = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs2', alphas2) att_fea2 = tf.reduce_sum(att_outputs2, 1) #alpha with tf.name_scope('User_alpha'): user_alpha = 0.2 user_embed = att_fea1 * user_alpha + att_fea2 * (1.0 - user_alpha) inp = tf.concat([self.item_eb, user_embed], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self,nums_name_ids, nums_function_ids, nums_tracks,\ EMBEDDING_DIM,HIDDEN_SIZE,ATTENTION_SIZE,use_negsampling=True): super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__init__(nums_name_ids, nums_function_ids, nums_tracks, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) with tf.name_scope("rnn_1"): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram("GRU_outputs", rnn_outputs) aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.neg_item_his_eb[:, 1:, :], mask=self.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 with tf.name_scope("Attention_layer_1"): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram("alpha_outputs", alphas) with tf.name_scope("rnn_2"): rnn_outputs2, final_state2 = dynamic_rnn( VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores=tf.expand_dims(alphas, -1), sequence_length=self.seq_len_ph, dtype=tf.float32, scope='gru2') tf.summary.histogram("final_state2", final_state2) inp = tf.concat([self.item_eb, self.item_his_eb_sum, final_state2], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_SLi_Rec_Fixed, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) # Attention layer(1) with tf.name_scope('Attention_layer_1'): att_outputs1, alphas1 = attention_HAN( self.item_history_embedding, attention_size=ATTENTION_SIZE, return_alphas=True) att_fea1 = tf.reduce_sum(att_outputs1, 1) tf.summary.histogram('att_fea1', att_fea1) item_history_embedding_new = tf.concat([ self.item_history_embedding, tf.expand_dims(self.timelast_history, -1) ], -1) item_history_embedding_new = tf.concat([ item_history_embedding_new, tf.expand_dims(self.timenow_history, -1) ], -1) # RNN layer with tf.name_scope('rnn'): rnn_outputs, final_state1 = dynamic_rnn( Time4LSTMCell(HIDDEN_SIZE), inputs=item_history_embedding_new, sequence_length=self.sequence_length, dtype=tf.float32, scope="time4lstm") tf.summary.histogram('LSTM_outputs', rnn_outputs) # Attention layer(2) with tf.name_scope('Attention_layer_2'): att_outputs2, alphas2 = attention_FCN(self.target_item_embedding, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs2', alphas2) att_fea2 = tf.reduce_sum(att_outputs2, 1) tf.summary.histogram('att_fea2', att_fea2) # alpha with tf.name_scope('User_alpha'): user_alpha = 0.2 user_embed = att_fea1 * user_alpha + att_fea2 * (1.0 - user_alpha) last_inps = tf.concat([self.target_item_embedding, user_embed], 1) self.fcn_net(last_inps, use_dice=True)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_NARM, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) # RNN layer(1) with tf.name_scope('rnn_1'): rnn_outputs1, final_state1 = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_history_embedding, sequence_length=self.sequence_length, dtype=tf.float32, scope="lstm_1") tf.summary.histogram('LSTM_outputs1', rnn_outputs1) # RNN layer(2) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_history_embedding, sequence_length=self.sequence_length, dtype=tf.float32, scope="lstm_2") tf.summary.histogram('LSTM_outputs2', rnn_outputs2) # Attention layer with tf.name_scope('Attention_layer'): att_outputs, alphas = attention_FCN(final_state1[1], rnn_outputs2, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) att_fea = tf.reduce_sum(att_outputs, 1) last_inps = tf.concat( [final_state1[1], att_fea, self.target_item_embedding], 1) self.fcn_net(last_inps, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=True): super(Model_DHAN, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.noclk_item_his_eb[:, 1:, :], self.mask[:, 1:], stag="gru") self.aux_loss = aux_loss_1 # han layer with tf.name_scope('Attention_layer'): attention_output,attention_output1 = first_attention(self.item_eb, self.item_his_eb, ATTENTION_SIZE, self.mask,self.cat_his_batch_ph,13) # att_fea_item_attention = tf.reduce_sum(attention_output1, 1) attention_output_2,cat_weight = second_attention(self.item_eb,attention_output, ATTENTION_SIZE, self.mask) att_fea = tf.reduce_sum(attention_output_2, 1) tf.summary.histogram('att_fea', att_fea) # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores = tf.expand_dims(alphas, -1), sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2,att_fea], 1) self.build_fcn_net(inp, use_dice=True)
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=False): super(Model_LSTMPP, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling) # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs1, alphas1 = attention_HAN( self.item_his_eb, attention_size=ATTENTION_SIZE, return_alphas=True) att_fea1 = tf.reduce_sum(att_outputs1, 1) tf.summary.histogram('att_fea1', att_fea1) # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, final_state1 = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="lstm1") tf.summary.histogram('LSTM_outputs', rnn_outputs) #alpha with tf.name_scope('User_alpha'): concat_all = tf.concat([ self.item_eb, att_fea1, final_state1[1], tf.expand_dims(self.time_now_his_batch_ph[:, -1], -1) ], 1) concat_att1 = tf.layers.dense(concat_all, 80, activation=tf.nn.sigmoid, name='concat_att1') concat_att2 = tf.layers.dense(concat_att1, 40, activation=tf.nn.sigmoid, name='concat_att2') user_alpha = tf.layers.dense(concat_att2, 1, activation=tf.nn.sigmoid, name='concat_att3') user_embed = att_fea1 * user_alpha + final_state1[1] * (1.0 - user_alpha) inp = tf.concat([self.item_eb, user_embed], 1) self.build_fcn_net(inp, use_dice=True)
def _augru_rnn(self, queries, inputs, inputs_length, params): rnn_hidden_size = inputs.get_shape()[2] att_scores = self._attention(queries, inputs, inputs_length, params) cell = AUGRUCell(num_units=rnn_hidden_size) outputs, last_states = dynamic_rnn(cell=cell, att_scores=att_scores, dtype=tf.float32, sequence_length=inputs_length, inputs=inputs, time_major=False) return outputs, last_states
def build_graph(self): # RNN layer(-s) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn( GRUCell(self.HIDDEN_SIZE), inputs=self.item_his_eb, max_iteration=self.options.max_rnn_while_loops, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) # Attention layer with tf.name_scope('Attention_layer_1'): att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, self.ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( GRUCell(self.HIDDEN_SIZE), inputs=att_outputs, max_iteration=self.options.max_rnn_while_loops, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") tf.summary.histogram('GRU2_Final_State', final_state2) inp = tf.concat([ self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2 ], 1) # Fully connected layer self.build_fcn_net(inp, use_dice=True)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_DIEN, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) # RNN layer(1) with tf.name_scope('rnn_1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_history_embedding, sequence_length=self.sequence_length, dtype=tf.float32, scope="gru_1") tf.summary.histogram('GRU_outputs', rnn_outputs) # Attention layer with tf.name_scope('Attention_layer'): att_outputs, alphas = attention_FCN(self.target_item_embedding, rnn_outputs, ATTENTION_SIZE, self.mask, softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True) tf.summary.histogram('alpha_outputs', alphas) # RNN layer(2) with tf.name_scope('rnn_2'): rnn_outputs2, final_state2 = dynamic_rnn( VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs, att_scores=tf.expand_dims(alphas, -1), sequence_length=self.sequence_length, dtype=tf.float32, scope="gru_2") tf.summary.histogram('GRU2_Final_State', final_state2) last_inps = tf.concat([self.target_item_embedding, final_state2], 1) self.fcn_net(last_inps, use_dice=True)
def __call__(self): # init placeholder ## 用户历史 item id self.history_x = tf.placeholder(dtype=tf.int32, [None, None], name="history_items") ## 用户历史 item 应的cate id list self.history_cat = tf.placeholder(dtype=tf.int32, [None, None], name="history_cats") ## 用户id self.users = tf.placeholder(dtype=tf.int32, [None,], name="user_ids") ## target的item id self.target_x = tf.placeholder(dtype=tf.int32, [None,], name="target_x") ## target item对应的cate id self.target_cat=tf.placeholder(dtype=tf.int32, [None,], name="target_cat") ## 历史行为的mask self.mask = tf.placeholder(dtype=tf.float32, [None, None], name="mask") ## 历史行为的长度 self.seq_len = tf.placeholder(dtype=tf.int32, [None], name="seq_len") ## 目标值 self.target = tf.placeholder(dtype=tf.float32, [None, None], name="target") if self.use_negsampling: ## 负采样数据 batch * seq_len * 采样数量 self.neg_x = tf.placeholder(dtype=tf.int32, [None, None, None], name="neg_items") self.neg_cat= tf.placeholder(dtype=tf.int32, [None, None, None], name="neg_cats") self.embedding() # build graph with tf.name_scope("rnn_layer_1"): rnn_outputs, _ = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(self.hidden_size), inputs=self.hist_x_embedding, sequence_length=self.seq_len, dtype=tf.float32, name="gru1") # 辅助loss self.aux_loss = self.auxiliary_loss(rnn_outputs[:,:-1,:], self.hist_x_embedding[:,1:,:], self.neg_x_embedding[:, 1:,:], self.mask[:, 1:], stag="gru") with tf.name_scope("attention_layer_1"): att_outputs, alphas = self.fcn_attention(self.x_embedding, rnn_outputs, self.attention_size, self.mask, softmax_stag=1, stag="1_1", mode="LIST", return_alphas=True) with tf.name_scope("rnn_2"): augru_ouputs, final_state = dynamic_rnn(VecAttGRUCell(self.hidden_size), inputs=rnn_outputs, att_score) inp = tf.concat([self.user_embeddings, self.x_embedding, self.hist_x_embedding, self.x_embedding*self.hist_x_embedding, final_state], axis=1) self.fcn_net(inp, use_dice=True)
def model_fn(data_in): seq_in = data_in['sequence'] targets = data_in['target'] seq_in_one_hot = tf.one_hot(seq_in, depth=vocab_size) #build the dnc cell cell = DNCCell(StatelessCell("linear", features=8), memory_size=8, word_size=8, num_reads=1, num_writes=1) output, _, final_loop_state = dynamic_rnn( seq_in_one_hot, cell, visualization.loop_state_fn, visualization.initial_loop_state()) logits = DenseLayer("logits", vocab_size, activation=None)(output) preds = tf.argmax(tf.nn.softmax(logits), -1) #return dictionary of tensors to keep track of args_dict = {} with tf.variable_scope('Loss'): cross_entorpy = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits, labels=targets) #no loss at end of sequences in batch (Padding) # loss_weights_t = tf.clip_by_value(tf.cast(targets, tf.float32), 0.0, 1.0) # cross_entorpy = cross_entorpy * loss_weights_t loss = tf.reduce_mean(cross_entorpy) args_dict['loss'] = loss with tf.variable_scope('train'): o = tf.train.RMSPropOptimizer(learn_rate, momentum) gvs = o.compute_gradients(loss, var_list=tf.trainable_variables()) '''clip gradients''' gradients, variables = zip(*gvs) gradients, _ = tf.clip_by_global_norm(gradients, norm_clip) capped_gvs = zip(gradients, variables) args_dict['optimizer'] = o.apply_gradients(capped_gvs) #track loss average every 100 steps args_dict['avg_loss'] = average_tracking.average_tracker(loss) #track loop state in tensorboard args_dict['mem_view'] = visualization.assemble_mem_view( final_loop_state, [seq_in, preds, targets], vocab_size) return args_dict
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_GRU4REC, self).__init__(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) with tf.name_scope('rnn1'): rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru1") _, final_state_1 = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=rnn_outputs, sequence_length=self.seq_len_ph, dtype=tf.float32, scope="gru2") with tf.name_scope('rnn1'): item_user_len = tf.reduce_sum(self.item_user_his_mask, axis=-1) item_user_rnn_outputs, _ = dynamic_rnn( GRUCell(HIDDEN_SIZE), inputs=self.item_user_his_uid_batch_embedded, sequence_length=item_user_len, dtype=tf.float32, scope="gru3") _, final_state_2 = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=item_user_rnn_outputs, sequence_length=item_user_len, dtype=tf.float32, scope="gru4") inp = tf.concat([ self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state_1, final_state_2 ], 1) # Fully connected layer self.build_fcn_net(inp)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_LSTMPP, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) # Attention layer with tf.name_scope('Attention_layer'): att_outputs, alphas = attention_HAN(self.item_history_embedding, attention_size=ATTENTION_SIZE, return_alphas=True) att_fea = tf.reduce_sum(att_outputs, 1) tf.summary.histogram('att_fea', att_fea) # RNN layer with tf.name_scope('rnn'): rnn_outputs, final_state = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_history_embedding, sequence_length=self.sequence_length, dtype=tf.float32, scope="lstm") tf.summary.histogram('LSTM_outputs', rnn_outputs) # alpha with tf.name_scope('User_alpha'): concat_all = tf.concat([ self.target_item_embedding, att_fea, final_state[1], tf.expand_dims(self.timenow_history[:, -1], -1) ], 1) concat_att1 = tf.layers.dense(concat_all, 80, activation=tf.nn.sigmoid, name='concat_att1') concat_att2 = tf.layers.dense(concat_att1, 40, activation=tf.nn.sigmoid, name='concat_att2') user_alpha = tf.layers.dense(concat_att2, 1, activation=tf.nn.sigmoid, name='concat_att3') user_embed = att_fea * user_alpha + final_state[1] * (1.0 - user_alpha) last_inps = tf.concat([self.target_item_embedding, user_embed], 1) self.fcn_net(last_inps, use_dice=True)
def __init__(self,n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN=256, use_negsample=False): super(Model_GRU4RECEXT, self).__init__(n_uid, n_mid, EMBEDDING_DIM, HIDDEN_SIZE, BATCH_SIZE, SEQ_LEN, use_negsample, Flag="GRU4RECEXT") with tf.name_scope('rnn_1'): self.sequence_length = tf.Variable([SEQ_LEN] * BATCH_SIZE) rnn_outputs, final_state1 = dynamic_rnn(GRUCell(3*EMBEDDING_DIM), inputs=self.item_his_eb, sequence_length=self.sequence_length, dtype=tf.float32, scope="gru1") tf.summary.histogram('GRU_outputs', rnn_outputs) if use_negsample: aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :], self.neg_his_eb[:, 1:, :], self.mask[:, 1:], stag = "bigru_0") self.aux_loss = aux_loss_1 inp = tf.concat([self.item_eb, self.item_his_eb_sum, final_state1, self.side_eb_sum, self.tags_eb_sum], 1) self.build_fcn_net(inp, use_dice=False)
def __init__(self, user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE): super(Model_LSTM, self).__init__(user_number, item_number, cate_number, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE) # RNN layer with tf.name_scope('rnn'): rnn_outputs, final_state = dynamic_rnn( LSTMCell(HIDDEN_SIZE), inputs=self.item_history_embedding, sequence_length=self.sequence_length, dtype=tf.float32, scope="lstm") tf.summary.histogram('LSTM_outputs', rnn_outputs) last_inps = tf.concat([self.target_item_embedding, final_state[1]], 1) self.fcn_net(last_inps, use_dice=False)