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)
