def build_fcn_net(self, inp, use_dice=False):
def dtype_getter(getter, name, dtype=None, *args, **kwargs):
var = getter(name, dtype=self.model_dtype, *args, **kwargs)
return var
with tf.compat.v1.variable_scope("fcn",
custom_getter=dtype_getter,
dtype=self.model_dtype):
bn1 = tf.compat.v1.layers.batch_normalization(inputs=inp,
name='bn1')
dnn1 = tf.compat.v1.layers.dense(bn1,
200,
activation=None,
name='f1')
if use_dice:
dnn1 = dice(dnn1, name='dice_1', data_type=self.model_dtype)
else:
dnn1 = prelu(dnn1, 'prelu1')
dnn2 = tf.compat.v1.layers.dense(dnn1,
80,
activation=None,
name='f2')
if use_dice:
dnn2 = dice(dnn2, name='dice_2', data_type=self.model_dtype)
else:
dnn2 = prelu(dnn2, 'prelu2')
dnn3 = tf.compat.v1.layers.dense(dnn2,
2,
activation=None,
name='f3')
self.y_hat = tf.nn.softmax(dnn3) + 0.00000001
with tf.name_scope("Metrics"):
#with tf.compat.v1.variable_scope("Metrics", custom_getter=dtype_getter, dtype=self.model_dtype):
# Cross-entropy loss and optimizer initialization
ctr_loss = -tf.reduce_mean(
tf.math.log(self.y_hat) * self.target_ph)
self.loss = ctr_loss
if self.use_negsampling:
self.loss += self.aux_loss
tf.compat.v1.summary.scalar('loss', self.loss)
# self.optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=self.lr).minimize(self.loss)
# self.optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate=self.lr).minimize(self.loss)
# self.optimizer = tf.compat.v1.train.MomentumOptimizer(learning_rate=self.lr, momentum=0.9).minimize(self.loss)
# convert sparse optimizer to dense optimizer
adam_optimizer = tf.compat.v1.train.AdamOptimizer(
learning_rate=self.lr)
gradients = adam_optimizer.compute_gradients(self.loss)
gradients = self._sparse_to_dense_grads(gradients)
self.optimizer = adam_optimizer.apply_gradients(gradients)
# Accuracy metric
self.accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.round(self.y_hat), self.target_ph),
self.model_dtype))
tf.compat.v1.summary.scalar('accuracy', self.accuracy)
self.merged = tf.compat.v1.summary.merge_all()
def build_fcn_net(self, inp, use_dice=False):
bn1 = tf.layers.batch_normalization(inputs=inp, name='bn1', training=True)
dnn1 = tf.layers.dense(
bn1, 200, activation=None, kernel_initializer=get_tf_initializer(), name='f1')
if use_dice:
dnn1 = dice(dnn1, name='dice_1')
else:
dnn1 = prelu(dnn1)
dnn2 = tf.layers.dense(
dnn1, 80, activation=None, kernel_initializer=get_tf_initializer(), name='f2')
if use_dice:
dnn2 = dice(dnn2, name='dice_2')
else:
dnn2 = prelu(dnn2)
dnn3 = tf.layers.dense(
dnn2, 2, activation=None, kernel_initializer=get_tf_initializer(), name='f3')
self.y_hat = tf.nn.softmax(dnn3) + 0.00000001
with tf.name_scope('Metrics'):
ctr_loss = - \
tf.reduce_mean(tf.log(self.y_hat) * self.tensors.target)
self.loss = ctr_loss
if self.use_negsampling:
self.loss += self.aux_loss
else:
self.aux_loss = tf.constant(0.0)
# Accuracy metric
self.accuracy = tf.reduce_mean(
tf.cast(tf.equal(tf.round(self.y_hat), self.tensors.target), tf.float32))
def build_fcn_net(self, inp, use_dice=False):
bn1 = tf.layers.batch_normalization(inputs=inp, name='bn1', training=True)
dnn1 = tf.layers.dense(bn1, 200, activation=None, kernel_initializer=get_tf_initializer(), name='f1')
if use_dice:
dnn1 = dice(dnn1, name='dice_1')
else:
dnn1 = prelu(dnn1)
dnn2 = tf.layers.dense(dnn1, 80, activation=None, kernel_initializer=get_tf_initializer(), name='f2')
if use_dice:
dnn2 = dice(dnn2, name='dice_2')
else:
dnn2 = prelu(dnn2)
dnn3 = tf.layers.dense(dnn2, 2, activation=None, kernel_initializer=get_tf_initializer(), name='f3')
self.y_hat = tf.nn.softmax(dnn3) + 0.00000001
with tf.name_scope('Metrics'):
ctr_loss = - \
tf.reduce_mean(tf.log(self.y_hat) * self.tensors.target)
self.loss = ctr_loss
if self.use_negsampling:
self.loss += self.aux_loss
else:
self.aux_loss = tf.constant(0.0)
# Accuracy metric
self.accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.round(self.y_hat), self.tensors.target), tf.float32))
def build_fcn_net_rocket(self, booster_inp, light_inp, use_dice = False):
bn1 = tf.layers.batch_normalization(inputs=booster_inp, name='bn1', training=True)
bn1_rocket = tf.layers.batch_normalization(inputs=light_inp, name='bn1_rocket', training=True)
dnn1 = tf.layers.dense(bn1, 200, activation=None, kernel_initializer=get_tf_initializer(), name='f1')
dnn1_rocket = tf.layers.dense(bn1_rocket, 200, activation=None, kernel_initializer=get_tf_initializer(), name='f1_rocket')
if use_dice:
dnn1 = dice(dnn1, name='dice_1')
dnn1_rocket = dice(dnn1_rocket, name='dice_rocket_1')
else:
dnn1 = prelu(dnn1, scope='prelu_1')
dnn1_rocket = prelu(dnn1_rocket, scope='prelu_rocket_1')
dnn2 = tf.layers.dense(dnn1, 80, activation=None, kernel_initializer=get_tf_initializer(), name='f2')
dnn2_rocket = tf.layers.dense(dnn1_rocket, 80, activation=None, kernel_initializer=get_tf_initializer(), name='f2_rocket')
if use_dice:
dnn2 = dice(dnn2, name='dice_2')
dnn2_rocket = dice(dnn2_rocket, name='dice_rocket_2')
else:
dnn2 = prelu(dnn2, scope='prelu_2')
dnn2_rocket = prelu(dnn2_rocket, scope='prelu_rocket_2')
dnn3 = tf.layers.dense(dnn2, 2, activation=None, kernel_initializer=get_tf_initializer(), name='f3')
dnn3_rocket = tf.layers.dense(dnn2_rocket, 2, activation=None, kernel_initializer=get_tf_initializer(), name='f3_rocket')
self.y_hat_booster = tf.nn.softmax(dnn3) + 0.00000001
self.y_hat_light = tf.nn.softmax(dnn3_rocket) + 0.00000001
self.y_hat = self.y_hat_light
with tf.name_scope('Metrics'):
# Cross-entropy loss and optimizer initialization
ctr_loss = - tf.reduce_mean(tf.log(self.y_hat_booster) * self.tensors.target)
ctr_loss_rocket = - tf.reduce_mean(tf.log(self.y_hat_light) * self.tensors.target)
hint_loss = tf.reduce_mean((tf.stop_gradient(dnn3) - dnn3_rocket)**2)
self.loss = ctr_loss + ctr_loss_rocket + 0.3 * hint_loss
self.ctr_loss = ctr_loss
self.ctr_loss_rocket = ctr_loss_rocket
self.hint_loss = hint_loss
if self.use_negsampling:
self.loss += self.aux_loss
# Accuracy metric
self.accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.round(self.y_hat), self.tensors.target), tf.float32))
def __init__(self,user_count,item_count,cate_count,cate_list):
# self.u = tf.placeholder(tf.int32,[None,],name='user')
self.i = tf.placeholder(tf.int32,[None,],name='item')
self.j = tf.placeholder(tf.int32,[None,],name='item_j')
self.y = tf.placeholder(tf.float32,[None,],name='label')
self.hist_i = tf.placeholder(tf.int32,[None,None],name='history_i')
self.sl = tf.placeholder(tf.int32, [None,] , name='sequence_length')
self.lr = tf.placeholder(tf.float64,name='learning_rate')
hidden_units = 32
# user_emb_w = tf.get_variable("user_emb_w",[user_count,hidden_units])
item_emb_w = tf.get_variable("item_emb_w",[item_count,hidden_units//2])
item_b = tf.get_variable("item_b",[item_count],initializer=tf.constant_initializer(0.0))
cate_emb_w = tf.get_variable("cate_emb_w",[cate_count,hidden_units//2])
cate_list = tf.convert_to_tensor(cate_list,dtype=tf.int64)
# u_emb = tf.nn.embedding_lookup(user_emb_w,self.u)
# ic是item到category的转换
self.ic = tf.gather(cate_list,self.i)
i_emb = tf.concat(values=[
tf.nn.embedding_lookup(item_emb_w,self.i),
tf.nn.embedding_lookup(cate_emb_w,self.ic)
],axis=1)
i_b = tf.gather(item_b,self.i)
self.jc = tf.gather(cate_list, self.j)
j_emb = tf.concat([
tf.nn.embedding_lookup(item_emb_w, self.j),
tf.nn.embedding_lookup(cate_emb_w, self.jc),
], axis=1)
j_b = tf.gather(item_b, self.j)
self.hc = tf.gather(cate_list, self.hist_i)
h_emb = tf.concat([
tf.nn.embedding_lookup(item_emb_w, self.hist_i),
tf.nn.embedding_lookup(cate_emb_w, self.hc),
], axis=2)
hist = attention(i_emb,h_emb,self.sl)
hist = tf.layers.batch_normalization(inputs=hist)
hist = tf.reshape(hist,[-1,hidden_units])
hist = tf.layers.dense(hist,hidden_units)
u_emb = hist
# fcn begin
din_i = tf.concat([u_emb, i_emb], axis=-1)
din_i = tf.layers.batch_normalization(inputs=din_i, name='b1')
d_layer_1_i = tf.layers.dense(din_i, 80, activation=None, name='f1')
d_layer_1_i = dice(d_layer_1_i, name='dice_1_i')
d_layer_2_i = tf.layers.dense(d_layer_1_i, 40, activation=None, name='f2')
d_layer_2_i = dice(d_layer_2_i, name='dice_2_i')
d_layer_3_i = tf.layers.dense(d_layer_2_i, 1, activation=None, name='f3')
din_j = tf.concat([u_emb, j_emb], axis=-1)
din_j = tf.layers.batch_normalization(inputs=din_j, name='b1', reuse=True)
d_layer_1_j = tf.layers.dense(din_j, 80, activation=None, name='f1', reuse=True)
d_layer_1_j = dice(d_layer_1_j, name='dice_1_j')
d_layer_2_j = tf.layers.dense(d_layer_1_j, 40, activation=None, name='f2', reuse=True)
d_layer_2_j = dice(d_layer_2_j, name='dice_2_j')
d_layer_3_j = tf.layers.dense(d_layer_2_j, 1, activation=None, name='f3', reuse=True)
d_layer_3_i = tf.reshape(d_layer_3_i, [-1])
d_layer_3_j = tf.reshape(d_layer_3_j, [-1])
x = i_b - j_b + d_layer_3_i - d_layer_3_j # [B]
self.logits = i_b + d_layer_3_i
# logits for all item:
u_emb_all = tf.expand_dims(u_emb, 1)
u_emb_all = tf.tile(u_emb_all, [1, item_count, 1])
all_emb = tf.concat([
item_emb_w,
tf.nn.embedding_lookup(cate_emb_w, cate_list)
], axis=1)
all_emb = tf.expand_dims(all_emb, 0)
all_emb = tf.tile(all_emb, [512, 1, 1])
din_all = tf.concat([u_emb_all, all_emb], axis=-1)
din_all = tf.layers.batch_normalization(inputs=din_all, name='b1', reuse=True)
d_layer_1_all = tf.layers.dense(din_all, 80, activation=None, name='f1', reuse=True)
d_layer_1_all = dice(d_layer_1_all, name='dice_1_all')
d_layer_2_all = tf.layers.dense(d_layer_1_all, 40, activation=None, name='f2', reuse=True)
d_layer_2_all = dice(d_layer_2_all, name='dice_2_all')
d_layer_3_all = tf.layers.dense(d_layer_2_all, 1, activation=None, name='f3', reuse=True)
d_layer_3_all = tf.reshape(d_layer_3_all, [-1, item_count])
self.logits_all = tf.sigmoid(item_b + d_layer_3_all)
# -- fcn end -------
self.mf_auc = tf.reduce_mean(tf.to_float(x > 0))
self.score_i = tf.sigmoid(i_b + d_layer_3_i)
self.score_j = tf.sigmoid(j_b + d_layer_3_j)
self.score_i = tf.reshape(self.score_i, [-1, 1])
self.score_j = tf.reshape(self.score_j, [-1, 1])
self.p_and_n = tf.concat([self.score_i, self.score_j], axis=-1)
# Step variable
self.global_step = tf.Variable(0, trainable=False, name='global_step')
self.global_epoch_step = \
tf.Variable(0, trainable=False, name='global_epoch_step')
self.global_epoch_step_op = \
tf.assign(self.global_epoch_step, self.global_epoch_step + 1)
# loss and train
self.loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=self.logits,
labels=self.y)
)
trainable_params = tf.trainable_variables()
self.train_op = tf.train.GradientDescentOptimizer(learning_rate=self.lr).minimize(self.loss)
'''
import matplotlib.pyplot as plt
from Dice import dice
#1) Set up dice: elements
#2) Set up number of dice: dice objects
#3) Set up number of rolls and collect data
#4) Perform probability analysis
elements = [int(x) for x in raw_input('What are the faces of the dice? ').split(' ')]
number_of_dice = int(raw_input('How many dice do you want? '))
number_of_rolls = int(raw_input('How many rolls would you like to perform? '))
#Set up dice
Dice = [dice(elements) for x in range(0, number_of_dice)]
#How should I store data? Dictionary is fast.
data = {x: 0 for x in range(number_of_dice*min(elements), number_of_dice*max(elements)+1)}
data1 = {x: 0 for x in range(number_of_dice*min(elements), number_of_dice*max(elements)+1)}
#Rolling time! (2 experiments: One with no reroll, the other with blank rerolls)
#Experiment 1
for n in range(0, number_of_rolls):
die_sum = 0
for die in Dice:
die.roll()
die_sum += die.face
data[die_sum] += 1
def __init__(self, item_count, keyword_count, tag1_count, tag2_count, tag3_count, ks1_count,
ks2_count, user_features_num, item_features_num, user_features_dim, item_features_dim,
embedding_size=8, hidden_units=64, deep_layer=[80, 40, 1], lamda=0.1):
# item_count：item个数
# keyword_count：关键词个数
# tag1_count：v4标签1个数
# tag2_count：v4标签2个数
# tag3_count：v4标签3个数
# ks1_count：v4关键词1个数
# ks2_count：v4关键词2个数
# user_features_num：用户固有属性个数
# item_features_num：物品固有属性个数
# user_features_dim：用户所有固有属性的唯一值个数
# item_features_dim：物品固有属性的唯一值个数
# 调参
# embedding_size ：普通嵌入层神经元个数
# hidden_units:注意力机制嵌入层的隐藏层神经元个数
# deep_layer:全连接层的神经元个数
# 组成
# user_feature 用户固有属性
# item_feature 产品固有属性
# item 当前物品
# keyword v2关键词
# tag1 语义标签1
# tag2 语义标签2
# tag3 语义标签3
# ks1 语义关键词1
# ks2 语义关键词2
# hist_item 历史记录的物品
# hist_keyword 历史记录的关键词
# sl 用户，历史评论产品的个数
# 输入
self.y = tf.placeholder(tf.float32, [None, ], name='y') # [B]
# [B, user_features_num]
self.user_feature = tf.placeholder(tf.int32, [None, user_features_num], name='user_feature')
# [B, item_features_num]
self.item_feature = tf.placeholder(tf.int32, [None, item_features_num], name='item_feature')
# self.item = tf.placeholder(tf.int32, [None, ], name='item') # [B]
self.item_id = tf.placeholder(tf.int32, [None, ], name='item_id')
self.keyword = tf.placeholder(tf.int32, [None, ], name='keyword')
self.tag1 = tf.placeholder(tf.int32, [None, ], name='tag1')
self.tag2 = tf.placeholder(tf.int32, [None, ], name='tag2')
self.tag3 = tf.placeholder(tf.int32, [None, ], name='tag3')
self.ks1 = tf.placeholder(tf.int32, [None, ], name='ks1')
self.ks2 = tf.placeholder(tf.int32, [None, ], name='ks2')
# self.hist_item = tf.placeholder(tf.int32, [None, None], name='hist_item') # [B, T] hist就是history，历史评论过的产品
self.hist_item = tf.placeholder(tf.int32, [None, None], name='hist_item') # [B, T]
self.hist_keyword = tf.placeholder(tf.int32, [None, None], name='hist_keyword') # [B, T]
self.hist_tag1 = tf.placeholder(tf.int32, [None, None], name='hist_tag1') # [B, T]
self.hist_tag2 = tf.placeholder(tf.int32, [None, None], name='hist_tag2') # [B, T]
self.hist_tag3 = tf.placeholder(tf.int32, [None, None], name='hist_tag3') # [B, T]
self.hist_ks1 = tf.placeholder(tf.int32, [None, None], name='hist_ks1') # [B, T]
self.hist_ks2 = tf.placeholder(tf.int32, [None, None], name='hist_ks2') # [B, T]
self.sl = tf.placeholder(tf.int32, [None, ], name='sl') # [B]
self.lr = tf.placeholder(tf.float64, [], name='lr') # [1,1]
self.keep_prob = tf.placeholder(tf.float32, [], name='keep_prob')
# 变量
# [user_count，self.embedding_size] user_count一个特征的维度，高维
user_feature_emb_w = tf.get_variable("user_feature_emb_w",
[user_features_dim,
embedding_size],
initializer=tf.contrib.layers.xavier_initializer(
uniform=False,
dtype=tf.float32))
item_feature_emb_w = tf.get_variable("item_feature_emb_w",
[item_features_dim, embedding_size],
initializer=tf.contrib.layers.xavier_initializer(
uniform=False,
dtype=tf.float32))
# item_emb_w = tf.get_variable("item_emb_w", [item_count, hidden_units // 3]) # 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
# 偏差 b
item_b = tf.get_variable("item_b", [item_count],
initializer=tf.constant_initializer(0.0))
item_emb_w = tf.get_variable("item_emb_w",
[item_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False,
dtype=tf.float32))
keyword_emb_w = tf.get_variable("keyword_emb_w",
[keyword_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False,
dtype=tf.float32))
tag1_emb_w = tf.get_variable("tag1_emb_w",
[tag1_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32))
tag2_emb_w = tf.get_variable("tag2_emb_w",
[tag2_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32))
tag3_emb_w = tf.get_variable("tag3_emb_w",
[tag3_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32))
ks1_emb_w = tf.get_variable("ks1_emb_w",
[ks1_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32))
ks2_emb_w = tf.get_variable("ks2_emb_w",
[ks2_count, hidden_units],
initializer=tf.contrib.layers.xavier_initializer(uniform=False, dtype=tf.float32))
tf.summary.histogram("user_feature_emb_w", user_feature_emb_w)
tf.summary.histogram("item_feature_emb_w", item_feature_emb_w)
# tf.summary.histogram("item_emb_w", item_emb_w)
tf.summary.histogram("item_b", item_b)
tf.summary.histogram("item_emb_w", item_emb_w)
tf.summary.histogram("keyword_emb_w", keyword_emb_w)
tf.summary.histogram("tag1_emb_w", tag1_emb_w)
tf.summary.histogram("tag2_emb_w", tag2_emb_w)
tf.summary.histogram("tag3_emb_w", tag3_emb_w)
tf.summary.histogram("ks1_emb_w", ks1_emb_w)
tf.summary.histogram("ks2_emb_w", ks2_emb_w)
# hidden_units = H
# -- 嵌入层 start ---
# tf.nn.embedding_lookup(item_emb_w, self.item) # [B ，hidden_units // 3]
item_emb = tf.nn.embedding_lookup(item_emb_w, self.item_id) # [B ，hidden_units // 2] = [B, H // 3]
keyword_emb = tf.nn.embedding_lookup(keyword_emb_w, self.keyword)
tag1_emb = tf.nn.embedding_lookup(tag1_emb_w, self.tag1)
tag2_emb = tf.nn.embedding_lookup(tag2_emb_w, self.tag2)
tag3_emb = tf.nn.embedding_lookup(tag3_emb_w, self.tag3)
ks1_emb = tf.nn.embedding_lookup(ks1_emb_w, self.ks1)
ks2_emb = tf.nn.embedding_lookup(ks2_emb_w, self.ks2)
i_b = tf.gather(item_b, self.item_id)
# 在shape【0，1，2】某一个维度上连接
# tf.nn.embedding_lookup(item_emb_w, self.hist_item) # [B, T, hidden_units // 3]
hist_item_emb = tf.nn.embedding_lookup(item_emb_w, self.hist_item) # [B, T, hidden_units // 3]
hist_keyword_emb = tf.nn.embedding_lookup(keyword_emb_w, self.hist_keyword) # [B, T, hidden_units // 3]
hist_tag1_emb = tf.nn.embedding_lookup(tag1_emb_w, self.hist_tag1) # [B, T, hidden_units // 3]
hist_tag2_emb = tf.nn.embedding_lookup(tag2_emb_w, self.hist_tag2) # [B, T, hidden_units // 3]
hist_tag3_emb = tf.nn.embedding_lookup(tag3_emb_w, self.hist_tag3) # [B, T, hidden_units // 3]
hist_ks1_emb = tf.nn.embedding_lookup(ks1_emb_w, self.hist_ks1) # [B, T, hidden_units // 3]
hist_ks2_emb = tf.nn.embedding_lookup(ks2_emb_w, self.hist_ks2) # [B, T, hidden_units // 3]
# [B, T, H]
# -- 嵌入层 end ---
# -- attention start ---
hist_item = attention(item_emb, hist_item_emb, self.sl) # [B, 1, H]
hist_item = tf.layers.batch_normalization(inputs=hist_item)
hist_item = tf.reshape(hist_item, [-1, hidden_units]) # [B, H]
hist_item = tf.layers.dense(hist_item, hidden_units) # [B, H]
hist_keyword = attention(keyword_emb, hist_keyword_emb, self.sl) # [B, 1, H]
hist_keyword = tf.layers.batch_normalization(inputs=hist_keyword)
hist_keyword = tf.reshape(hist_keyword, [-1, hidden_units]) # [B, H]
hist_keyword = tf.layers.dense(hist_keyword, hidden_units) # [B, H]
hist_tag1 = attention(tag1_emb, hist_tag1_emb, self.sl) # [B, 1, H]
hist_tag1 = tf.layers.batch_normalization(inputs=hist_tag1)
hist_tag1 = tf.reshape(hist_tag1, [-1, hidden_units]) # [B, H]
hist_tag1 = tf.layers.dense(hist_tag1, hidden_units) # [B, H]
hist_tag2 = attention(tag2_emb, hist_tag2_emb, self.sl) # [B, 1, H]
hist_tag2 = tf.layers.batch_normalization(inputs=hist_tag2)
hist_tag2 = tf.reshape(hist_tag2, [-1, hidden_units]) # [B, H]
hist_tag2 = tf.layers.dense(hist_tag2, hidden_units) # [B, H]
hist_tag3 = attention(tag3_emb, hist_tag3_emb, self.sl) # [B, 1, H]
hist_tag3 = tf.layers.batch_normalization(inputs=hist_tag3)
hist_tag3 = tf.reshape(hist_tag3, [-1, hidden_units]) # [B, H]
hist_tag3 = tf.layers.dense(hist_tag3, hidden_units) # [B, H]
hist_ks1 = attention(ks1_emb, hist_ks1_emb, self.sl) # [B, 1, H]
hist_ks1 = tf.layers.batch_normalization(inputs=hist_ks1)
hist_ks1 = tf.reshape(hist_ks1, [-1, hidden_units]) # [B, H]
hist_ks1 = tf.layers.dense(hist_ks1, hidden_units) # [B, H]
hist_ks2 = attention(ks2_emb, hist_ks2_emb, self.sl) # [B, 1, H]
hist_ks2 = tf.layers.batch_normalization(inputs=hist_ks2)
hist_ks2 = tf.reshape(hist_ks2, [-1, hidden_units]) # [B, H]
hist_ks2 = tf.layers.dense(hist_ks2, hidden_units) # [B, H]
# -- attention end ---
# -- 普通嵌入层 --
user_feature = tf.nn.embedding_lookup(user_feature_emb_w,
self.user_feature) # [B, embedding_size, user_features_num]
user_feature = tf.reshape(user_feature, [-1, embedding_size * user_features_num])
item_feature = tf.nn.embedding_lookup(item_feature_emb_w,
self.item_feature) # [B, embedding_size, user_features_num]
item_feature = tf.reshape(item_feature, [-1, embedding_size * item_features_num])
# -- 普通嵌入层 --
# -- fcn begin -------
# -- 训练集全连接层 开始 -------
din_i = tf.concat(
[hist_item, hist_keyword, hist_tag1, hist_tag2, hist_tag3, hist_ks1, hist_ks2,
item_emb, keyword_emb, tag1_emb, tag2_emb, tag3_emb, ks1_emb, ks2_emb,
user_feature, item_feature], axis=-1)
d_layer_1_i = tf.layers.dense(din_i, deep_layer[0], activation=None, name='f1') # 全连接层 [B, 80]
d_layer_1_i = dice(d_layer_1_i, name='dice_1_i')
d_layer_1_i = tf.nn.dropout(d_layer_1_i, self.keep_prob)
d_layer_1_i = tf.layers.batch_normalization(inputs=d_layer_1_i, name='b1')
d_layer_2_i = tf.layers.dense(d_layer_1_i, deep_layer[1], activation=None, name='f2')
d_layer_2_i = dice(d_layer_2_i, name='dice_2_i')
d_layer_2_i = tf.nn.dropout(d_layer_2_i, self.keep_prob)
d_layer_2_i = tf.layers.batch_normalization(inputs=d_layer_2_i, name='b2')
d_layer_3_i = tf.layers.dense(d_layer_2_i, deep_layer[2], activation=None, name='f3')
d_layer_3_i = tf.reshape(d_layer_3_i, [-1]) # 展开成行向量
self.logits = i_b + d_layer_3_i
self.sig_logits = tf.sigmoid(self.logits, name='sig_logits')
# -- 训练集全连接层 结束 -------
# Step variable
self.global_step = tf.Variable(0, trainable=False, name='global_step')
self.global_epoch_step = \
tf.Variable(0, trainable=False, name='global_epoch_step')
self.global_epoch_step_op = \
tf.assign(self.global_epoch_step, self.global_epoch_step + 1)
with tf.name_scope('loss'): # 损失
self.loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=self.logits, labels=self.y),
name='loss') + tf.losses.get_regularization_loss()
tf.summary.scalar('loss', self.loss)
optimizer = tf.train.AdamOptimizer(self.lr, name='adam')
self.train_op = optimizer.minimize(self.loss)
def __init__(self, user_count, item_count, cate_count, cate_list):
# shape: [B], user id。 (B：batch size)
self.u = tf.placeholder(tf.int32, [
None,
])
# shape: [B] i: 正样本的item
self.i = tf.placeholder(tf.int32, [
None,
])
# shape: [B] j: 负样本的item
self.j = tf.placeholder(tf.int32, [
None,
])
# shape: [B], y: label
self.y = tf.placeholder(tf.float32, [
None,
])
# shape: [B, T] #用户行为特征(User Behavior)中的item序列。
# T为最长序列的长度，用户序列少于T的用0填充
self.hist_i = tf.placeholder(tf.int32, [None, None])
# shape: [B]; sl：sequence length，User Behavior中每个用户行为序列的真实长度
self.sl = tf.placeholder(tf.int32, [
None,
])
# learning rate
self.lr = tf.placeholder(tf.float64, [])
hidden_units = 128
# shape: [U, H], user_id的embedding weight. U是user_id的hash bucket size
user_emb_w = tf.get_variable("user_emb_w", [user_count, hidden_units])
# shape: [I, H//2], item_id的embedding weight. I是item_id的hash bucket size
item_emb_w = tf.get_variable(
"item_emb_w", [item_count, hidden_units // 2]) # [I, H//2]
# shape: [I], item_id的embedding bias
item_b = tf.get_variable("item_b", [item_count],
initializer=tf.constant_initializer(0.0))
# shape: [C, H//2], cate_id的embedding weight.
cate_emb_w = tf.get_variable("cate_emb_w",
[cate_count, hidden_units // 2])
# shape: [C, H//2]
cate_list = tf.convert_to_tensor(cate_list, dtype=tf.int64)
# 正样本的cate
ic = tf.gather(cate_list, self.i)
# 正样本item_emb和cate_emb拼接，shape: [B, H]
i_emb = tf.concat(values=[
tf.nn.embedding_lookup(item_emb_w, self.i),
tf.nn.embedding_lookup(cate_emb_w, ic),
],
axis=1)
# 偏置b
i_b = tf.gather(item_b, self.i)
# 从cate_list中取出负样本的cate
jc = tf.gather(cate_list, self.j)
# 负样本item_emb和cate_emb拼接，shape: [B, H]
j_emb = tf.concat([
tf.nn.embedding_lookup(item_emb_w, self.j),
tf.nn.embedding_lookup(cate_emb_w, jc),
],
axis=1)
# 偏置b
j_b = tf.gather(item_b, self.j)
# 用户行为序列(User Behavior)中的cate序列
hc = tf.gather(cate_list, self.hist_i)
# 用户行为序列(User Behavior)物品的item_emb和cate_emb拼接，shape: [B, T, H]
h_emb = tf.concat([
tf.nn.embedding_lookup(item_emb_w, self.hist_i),
tf.nn.embedding_lookup(cate_emb_w, hc),
],
axis=2)
# attention操作
hist_i = attention(i_emb, h_emb, self.sl) # B * 1 * H
# -- attention end ---
hist = tf.layers.batch_normalization(inputs=hist_i)
hist = tf.reshape(hist, [-1, hidden_units]) # B * H
# 添加一层全连接层，hist为输入，hidden_units为输出维数
hist = tf.layers.dense(hist, hidden_units) #为啥？
u_emb = hist
# 下面两个全连接用来计算y'，i为正样本，j为负样本
# fcn begin
din_i = tf.concat([u_emb, i_emb], axis=-1)
din_i = tf.layers.batch_normalization(inputs=din_i, name='b1')
d_layer_1_i = tf.layers.dense(din_i, 80, activation=None, name='f1')
d_layer_1_i = dice(d_layer_1_i, name='dice_1_i')
d_layer_2_i = tf.layers.dense(d_layer_1_i,
40,
activation=None,
name='f2')
d_layer_2_i = dice(d_layer_2_i, name='dice_2_i')
d_layer_3_i = tf.layers.dense(d_layer_2_i,
1,
activation=None,
name='f3')
din_j = tf.concat([u_emb, j_emb], axis=-1)
din_j = tf.layers.batch_normalization(inputs=din_j,
name='b1',
reuse=True)
d_layer_1_j = tf.layers.dense(din_j,
80,
activation=None,
name='f1',
reuse=True)
d_layer_1_j = dice(d_layer_1_j, name='dice_1_j')
d_layer_2_j = tf.layers.dense(d_layer_1_j,
40,
activation=None,
name='f2',
reuse=True)
d_layer_2_j = dice(d_layer_2_j, name='dice_2_j')
d_layer_3_j = tf.layers.dense(d_layer_2_j,
1,
activation=None,
name='f3',
reuse=True)
d_layer_3_i = tf.reshape(d_layer_3_i, [-1]) # [B, 1]
d_layer_3_j = tf.reshape(d_layer_3_j, [-1]) # [B, 1]
# 预测的（y正-y负）
x = i_b - j_b + d_layer_3_i - d_layer_3_j # [B]
# 预测的（y正）
self.logits = i_b + d_layer_3_i
# logits for all item:
u_emb_all = tf.expand_dims(u_emb, 1)
u_emb_all = tf.tile(u_emb_all, [1, item_count, 1])
# 将所有的除u_emb_all外的embedding，concat到一起
all_emb = tf.concat(
[item_emb_w,
tf.nn.embedding_lookup(cate_emb_w, cate_list)],
axis=1)
all_emb = tf.expand_dims(all_emb, 0)
all_emb = tf.tile(all_emb, [512, 1, 1])
# 将所有的embedding，concat到一起
din_all = tf.concat([u_emb_all, all_emb], axis=-1)
din_all = tf.layers.batch_normalization(inputs=din_all,
name='b1',
reuse=True)
d_layer_1_all = tf.layers.dense(din_all,
80,
activation=None,
name='f1',
reuse=True)
d_layer_1_all = dice(d_layer_1_all, name='dice_1_all')
d_layer_2_all = tf.layers.dense(d_layer_1_all,
40,
activation=None,
name='f2',
reuse=True)
d_layer_2_all = dice(d_layer_2_all, name='dice_2_all')
d_layer_3_all = tf.layers.dense(d_layer_2_all,
1,
activation=None,
name='f3',
reuse=True)
d_layer_3_all = tf.reshape(d_layer_3_all, [-1, item_count])
self.logits_all = tf.sigmoid(item_b + d_layer_3_all)
# -- fcn end -------
self.mf_auc = tf.reduce_mean(tf.to_float(x > 0))
self.score_i = tf.sigmoid(i_b + d_layer_3_i)
self.score_j = tf.sigmoid(j_b + d_layer_3_j)
self.score_i = tf.reshape(self.score_i, [-1, 1])
self.score_j = tf.reshape(self.score_j, [-1, 1])
self.p_and_n = tf.concat([self.score_i, self.score_j], axis=-1)
# Step variable
self.global_step = tf.Variable(0, trainable=False, name='global_step')
self.global_epoch_step = tf.Variable(0,
trainable=False,
name='global_epoch_step')
self.global_epoch_step_op = tf.assign(self.global_epoch_step,
self.global_epoch_step + 1)
# loss and train
self.loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=self.logits,
labels=self.y))
trainable_params = tf.trainable_variables()
self.train_op = tf.train.GradientDescentOptimizer(
learning_rate=self.lr).minimize(self.loss)
