def predict_graph_onrecall_ori(self, is_negsample=False, reuse=False):
if reuse:
tf.get_variable_scope().reuse_variables()
model_para = self.model_para
self.input_predict = tf.placeholder(
'int32', [model_para['batch_size'], model_para['seq_len']],
name='input_predict')
self.input_recall = tf.placeholder(
'int32', [model_para['batch_size'], model_para['seq_len']],
name='input_recall') # candidate items
label_seq, dilate_input = self.model_graph(self.input_predict,
train=False)
if is_negsample:
logits_2D = dilate_input[:, -1:, :]
recall_mat = tf.nn.embedding_lookup(self.softmax_w,
self.input_recall)
logits_2D = tf.matmul(logits_2D,
tf.transpose(recall_mat, [0, 2, 1]))
logits_2D = tf.reshape(logits_2D,
[-1, tf.shape(self.input_recall)[1]])
recall_bias = tf.nn.embedding_lookup(self.softmax_b,
self.input_recall)
logits_2D = tf.add(logits_2D, recall_bias)
else:
# logits = ops.conv1d(tf.nn.relu(dilate_input), model_para['item_size'], name='logits')
logits = ops_compress.conv1d(tf.nn.relu(dilate_input[:, -1:, :]),
model_para['item_size'],
name='logits')
logits_2D = tf.reshape(logits, [-1, model_para['item_size']])
probs_flat = tf.nn.softmax(logits_2D, name='softmax')
self.g_probs = probs_flat
# newly added for weishi, since each input is one user (i.e., a batch), in fact we just need to rank the first batch, the below code is to select top-5
# self.top_k= tf.nn.top_k(self.g_probs[:,-1], k=model_para['top_k'],name='top-k')
# be carefule with the top-k values since the index represents the orders of your recalled items but not the original order.
self.top_k = tf.nn.top_k(self.g_probs,
k=model_para['top_k'],
name='top-k')
def train_graph(self): #, is_negsample=False):
model_para = self.model_para
self.itemseq_input = tf.placeholder(
'int32', [model_para['batch_size'], model_para['seq_len']],
name='itemseq_input')
label_seq, dilate_input = self.model_graph(self.itemseq_input,
train=True)
# dilate_input : [batch_size, seq_len, dilated_channels]
if model_para['SoftmaxType'] == "neg":
print("using neg")
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
self.softmax_w = tf.get_variable(
"softmax_w",
[model_para['item_size'], model_para['dilated_channels']],
tf.float32, tf.random_normal_initializer(0.0, 0.01))
self.softmax_b = tf.get_variable("softmax_b",
[model_para['item_size']],
tf.float32,
tf.constant_initializer(0.1))
label_flat = tf.reshape(
label_seq, [-1, 1]) # 1 is the number of positive example
num_sampled = int(
0.2 * model_para['item_size']) #sample 20% as negatives
# tf.nn.nce_loss
loss = tf.nn.sampled_softmax_loss(self.softmax_w, self.softmax_b,
label_flat, logits_2D,
num_sampled,
model_para['item_size'])
elif model_para['SoftmaxType'] == "FullSoftmax_conv":
print("using FullSoftmax_conv")
if model_para['dilated_channels'] != model_para['out_embed_size']:
self.softmax_pro_w = tf.get_variable(
"softmax_pro_w",
[model_para['dilated_channels'], model_para['embed_size']],
tf.float32, tf.random_normal_initializer(0.0, 0.01))
dilate_input = tf.tensordot(dilate_input,
self.softmax_pro_w,
axes=1)
logits = ops_compress.conv1d(tf.nn.relu(dilate_input),
model_para['item_size'],
name='logits')
logits_2D = tf.reshape(logits, [-1, model_para['item_size']])
label_flat = tf.reshape(label_seq, [-1])
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label_flat, logits=logits_2D)
elif model_para['SoftmaxType'] == "FullSoftmax" or model_para[
'SoftmaxType'] == "Block_Input_Full":
print("using FullSoftmax")
if model_para['dilated_channels'] != model_para['out_embed_size']:
self.softmax_pro_w = tf.get_variable(
"softmax_pro_w", [
model_para['dilated_channels'],
model_para['out_embed_size']
], tf.float32, tf.random_normal_initializer(0.0, 0.01))
dilate_input = tf.tensordot(dilate_input,
self.softmax_pro_w,
axes=1)
self.softmax_w = tf.get_variable(
"softmax_w",
[model_para['out_embed_size'], model_para['item_size']],
tf.float32, tf.random_normal_initializer(0.0, 0.01))
self.softmax_b = tf.get_variable("softmax_b",
[model_para['item_size']],
tf.float32,
tf.constant_initializer(0.1))
label_flat = tf.reshape(label_seq, [-1])
logits_2D = tf.reshape(dilate_input,
[-1, model_para['out_embed_size']])
logits_2D = tf.matmul(logits_2D, self.softmax_w)
logits_2D = tf.nn.bias_add(logits_2D, self.softmax_b)
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label_flat, logits=logits_2D)
elif model_para['SoftmaxType'] == "FullSoftmax_Tied":
print("using FullSoftmax_Tied")
if model_para['dilated_channels'] != model_para['embed_size']:
self.softmax_pro_w = tf.get_variable(
"softmax_pro_w",
[model_para['dilated_channels'], model_para['embed_size']],
tf.float32, tf.random_normal_initializer(0.0, 0.01))
dilate_input = tf.tensordot(dilate_input,
self.softmax_pro_w,
axes=1)
self.softmax_w = tf.transpose(self.allitem_embeddings.embedding)
# self.softmax_b = tf.get_variable("softmax_b", [model_para['item_size']], tf.float32,
# tf.constant_initializer(0.1))
label_flat = tf.reshape(label_seq, [-1])
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
logits_2D = tf.matmul(logits_2D, self.softmax_w)
# logits_2D = tf.nn.bias_add(logits_2D, self.softmax_b)
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=label_flat, logits=logits_2D)
elif model_para['SoftmaxType'] == "Block_for_Softmax":
print("using Block_for_Softmax")
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
block = model_para['block']
assert model_para['dilated_channels'] == model_para[
'out_embed_size']
softmax_layer = bs(input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
loss, _ = softmax_layer.loss(logits_2D,
tf.reshape(label_seq, [-1]), "loss")
elif (model_para['SoftmaxType'] == 'Block_Input_Softmax'
or model_para['SoftmaxType'] == 'Block_Input_Softmax_Inference'
) and model_para['factor'] != 1:
print("using Block_Input_Softmax")
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
block = model_para['block']
assert model_para['dilated_channels'] == model_para[
'out_embed_size']
softmax_layer = bs(input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
loss, _ = softmax_layer.loss(logits_2D,
tf.reshape(label_seq, [-1]), "loss")
elif model_para['SoftmaxType'] == 'LowrankSoftmax' and model_para[
'factor'] != 1:
print("using LowrankSoftmax")
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = lowranksoftmax.LowRankSoftmax(
input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
loss = softmax_layer.loss(logits_2D, tf.reshape(label_seq, [-1]),
"loss")
elif model_para[
'SoftmaxType'] == 'Block_Input_LowrankSoftmax' and model_para[
'factor'] != 1:
print("using Block_Input_LowrankSoftmax")
logits_2D = tf.reshape(dilate_input,
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = lowranksoftmax.LowRankSoftmax(
input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
loss = softmax_layer.loss(logits_2D, tf.reshape(label_seq, [-1]),
"loss")
self.loss = tf.reduce_mean(loss)
regularization = 0.001 * tf.reduce_mean(
[tf.nn.l2_loss(v) for v in tf.trainable_variables()])
self.loss = self.loss + regularization
def predict_graph_onrecall(self, reuse=False): #is_negsample=False,
if reuse:
tf.get_variable_scope().reuse_variables()
model_para = self.model_para #
self.input_predict = tf.placeholder(
'int32', [model_para['batch_size'], model_para['seq_len']],
name='input_predict')
self.input_recall = tf.placeholder(
'int32', [model_para['batch_size'], model_para['seq_len']],
name='input_recall') # candidate items
label_seq, dilate_input = self.model_graph(self.input_predict,
train=False)
# label_flat = tf.reshape(label_seq[:, -1:], [-1]) # [batch_size]
if model_para['SoftmaxType'] == 'neg_nowork':
logits_2D = dilate_input[:, -1:, :]
recall_mat = tf.nn.embedding_lookup(self.softmax_w,
self.input_recall)
logits_2D = tf.matmul(logits_2D,
tf.transpose(recall_mat, [0, 2, 1]))
logits_2D = tf.reshape(logits_2D,
[-1, tf.shape(self.input_recall)[1]])
recall_bias = tf.nn.embedding_lookup(self.softmax_b,
self.input_recall)
logits_2D = tf.add(logits_2D, recall_bias)
probs_flat = tf.nn.softmax(logits_2D, name='softmax')
elif model_para['SoftmaxType'] == 'neg':
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['out_embed_size']])
logits_2D = tf.matmul(logits_2D, tf.transpose(self.softmax_w))
logits_2D = tf.nn.bias_add(logits_2D, self.softmax_b)
probs_flat = tf.nn.softmax(logits_2D)
elif model_para['SoftmaxType'] == 'FullSoftmax_conv':
print("recall one valid using FullSoftmax_conv")
if model_para['dilated_channels'] != model_para['embed_size']:
dilate_input = tf.tensordot(dilate_input,
self.softmax_pro_w,
axes=1)
logits = ops_compress.conv1d(tf.nn.relu(dilate_input[:, -1:, :]),
model_para['item_size'],
name='logits')
logits_2D = tf.reshape(
logits,
[-1, model_para['item_size']]) #[batch_size, item_size]
probs_flat = tf.nn.softmax(logits_2D, name='softmax')
elif model_para["SoftmaxType"] == "FullSoftmax" or model_para[
'SoftmaxType'] == "Block_Input_Full" or model_para[
'SoftmaxType'] == "FullSoftmax_Tied":
print("valid using FullSoftmax")
if model_para['dilated_channels'] != model_para['out_embed_size']:
dilate_input = tf.tensordot(dilate_input,
self.softmax_pro_w,
axes=1)
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['out_embed_size']])
logits_2D = tf.matmul(logits_2D, self.softmax_w)
logits_2D = tf.nn.bias_add(logits_2D, self.softmax_b)
probs_flat = tf.nn.softmax(logits_2D)
elif model_para["SoftmaxType"] == "Block_for_Softmax":
print("recall one valid using Block_for_Softmax")
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['dilated_channels']
]) #[batch_size, dilated_channels]
block = model_para['block']
softmax_layer = bs(model_para["dilated_channels"],
block,
block_factor=model_para['factor'])
# loss, _ = softmax_layer.loss(logits_2D, label_flat, train=False, name="loss")
probs_flat = softmax_layer.softmax(logits_2D, name='softmax')
elif model_para["SoftmaxType"] == "Block_Input_Softmax" and model_para[
'factor'] != 1:
print("recall one valid using Block_Input_Softmax")
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = bs(model_para["dilated_channels"],
block,
block_factor=model_para['factor'])
# loss, _ = softmax_layer.loss(logits_2D, label_flat, train=False, name="loss")
probs_flat = softmax_layer.softmax(logits_2D, name='softmax')
elif model_para["SoftmaxType"] == "LowrankSoftmax":
print("recall one valid using LowrankSoftmax")
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = lowranksoftmax.LowRankSoftmax(
input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
# loss, _ = softmax_layer.loss(logits_2D, label_flat, train=False, name="loss")
probs_flat = softmax_layer.softmax(
logits_2D, name='softmax') # [batch_size, item_size]
elif model_para["SoftmaxType"] == "Block_Input_LowrankSoftmax":
print("recall one valid using Block_Input_LowrankSoftmax")
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = lowranksoftmax.LowRankSoftmax(
input_dim=model_para['dilated_channels'],
block=block,
block_factor=model_para['factor'])
# loss, _ = softmax_layer.loss(logits_2D, label_flat, train=False, name="loss")
probs_flat = softmax_layer.softmax(
logits_2D, name='softmax') # [batch_size, item_size]
elif model_para[
"SoftmaxType"] == "Block_Input_Softmax_Inference" and model_para[
'factor'] != 1:
print("recall one valid using Block_Input_Softmax")
logits_2D = tf.reshape(dilate_input[:, -1:, :],
[-1, model_para['dilated_channels']])
block = model_para['block']
softmax_layer = bs(model_para["dilated_channels"],
block=block,
block_factor=model_para['factor'])
# loss, _ = softmax_layer.loss(logits_2D, label_flat, train=False, name="loss")
probs_flat = softmax_layer.softmax_inference_top(
logits_2D, name='softmax', top_v=model_para['top_k'])
# self.loss_test = tf.reduce_mean(loss)
self.g_probs = probs_flat