def _forward(self, item_embs, user_emb): # (b,l,d), (b,d)
gate = tf.sigmoid(
self.feature_gate_item(item_embs) + tf.expand_dims(
self.feature_gate_user(user_emb), axis=1)) # (b,l,d)
self._reg_loss += l2_loss(*self.feature_gate_item.trainable_weights)
self._reg_loss += l2_loss(*self.feature_gate_user.trainable_weights)
# feature gating
gated_item = tf.multiply(item_embs, gate) # (b,l,d)
# instance gating
term1 = tf.matmul(gated_item,
tf.expand_dims(self.instance_gate_item,
axis=0)) # (b,l,d)x(1,d,1)->(b,l,1)
term2 = tf.matmul(user_emb,
self.instance_gate_user) # (b,d)x(d,l)->(b,l)
self._reg_loss += l2_loss(self.instance_gate_user,
self.instance_gate_item)
instance_score = tf.sigmoid(tf.squeeze(term1) + term2) # (b,l)
union_out = tf.multiply(gated_item,
tf.expand_dims(instance_score,
axis=2)) # (b,l,d)
union_out = tf.reduce_sum(union_out, axis=1) # (b,d)
instance_score = tf.reduce_sum(instance_score, axis=1, keep_dims=True)
union_out = union_out / instance_score # (b,d)
return union_out # (b,d)
def build_graph(self):
self._create_layer()
# generator
self.condition = tf.placeholder(tf.float32, [None, self.num_items])
self.g_zr_dims = tf.placeholder(tf.float32, [None, self.num_items])
self.g_output = self.gen(self.condition)
self.g_zr_loss = tf.reduce_mean(
tf.reduce_sum(tf.square(self.g_output - 0) * self.g_zr_dims,
1,
keepdims=True))
# discriminator
self.mask = tf.placeholder(
tf.float32, [None, self.num_items]) # purchased = 1, otherwise 0
fake_data = self.g_output * self.mask
fake_data = tf.concat([self.condition, fake_data], 1)
self.real_data = tf.placeholder(tf.float32, [None, self.num_items])
real_data = tf.concat([self.condition, self.real_data], 1)
d_fake = self.dis(fake_data)
d_real = self.dis(real_data)
g_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='gen')
d_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='dis')
# define loss & optimizer for G
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_fake, labels=tf.ones_like(d_fake)))
g_loss = g_loss + self.reg_G * l2_loss(*g_vars)
g_loss = g_loss + self.ZR_coefficient * self.g_zr_loss
if self.opt_g == 'sgd':
self.trainer_g = tf.train.GradientDescentOptimizer(
self.lr_G).minimize(g_loss, var_list=g_vars)
elif self.opt_g == 'adam':
self.trainer_g = tf.train.AdamOptimizer(self.lr_G).minimize(
g_loss, var_list=g_vars)
# define loss & optimizer for D
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_real, labels=tf.ones_like(d_real)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_fake, labels=tf.zeros_like(d_fake)))
d_loss = d_loss_real + d_loss_fake + self.reg_D * l2_loss(*d_vars)
if self.opt_d == 'sgd':
self.trainer_d = tf.train.GradientDescentOptimizer(
self.lr_D).minimize(d_loss, var_list=d_vars)
elif self.opt_d == 'adam':
self.trainer_d = tf.train.AdamOptimizer(self.lr_D).minimize(
d_loss, var_list=d_vars)
def _create_loss(self):
with tf.name_scope("loss"):
self.loss = tf.losses.log_loss(self.labels, self.output) + \
self.lambda_bilinear * l2_loss(self.embedding_Q) + \
self.gamma_bilinear * l2_loss(self.embedding_Q_) + \
self.eta_bilinear * l2_loss(self.W)
for i in range(min(len(self.n_hidden), len(self.reg_W))):
if self.reg_W[i] > 0:
self.loss = self.loss + self.reg_W[i] * l2_loss(
self.weights['h%d' % i])
def _create_loss(self):
with tf.name_scope("loss"):
p1, q1, self.output = self._create_inference(self.item_input)
if self.is_pairwise is True:
_, q2, self.output_neg = self._create_inference(
self.item_input_neg)
result = self.output - self.output_neg
self.loss = learner.pairwise_loss(
self.loss_function,
result) + self.reg_mlp * l2_loss(p1, q2, q1)
else:
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.reg_mlp * l2_loss(p1, q1)
def _create_loss(self):
with tf.name_scope("loss"):
# loss for L(Theta)
p1, r1, q1, b1, self.output = self._create_inference(
self.item_input)
if self.is_pairwise is True:
_, _, q2, b2, output_neg = self._create_inference(
self.item_input_neg)
self.result = self.output - output_neg
self.loss = learner.pairwise_loss(self.loss_function, self.result) + \
self.reg_mf * l2_loss(p1, r1, q2, q1, b1, b2, self.global_embedding)
else:
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.reg_mf * l2_loss(p1, r1, q1, b1, self.global_embedding)
def _create_loss(self):
with tf.name_scope("loss"):
UI_u, IU_i, IL_i, LI_l, self.output = self._create_inference(
self.item_input)
if self.is_pairwise is True:
_, IU_j, IL_j, _, output_neg = self._create_inference(
self.item_input_neg)
self.result = self.output - output_neg
self.loss = learner.pairwise_loss(self.loss_function, self.result) + \
self.reg_mf * l2_loss(UI_u, IU_i, IL_i, LI_l, IU_j, IL_j) + \
self.reg_w * l2_loss(self.W, self.h)
else:
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.reg_mf * l2_loss(UI_u, IU_i, IL_i, LI_l)
def _create_loss(self):
with tf.name_scope("loss"):
p1, q1, self.output = self._create_inference(self.user_input, self.item_input, self.num_idx)
if self.is_pairwise is True:
_, q2, output_neg = self._create_inference(self.user_input_neg, self.item_input_neg, self.num_idx_neg)
self.result = self.output - output_neg
self.loss = learner.pairwise_loss(self.loss_function, self.result) + \
self.lambda_bilinear * l2_loss(p1) + \
self.gamma_bilinear * l2_loss(q2, q1)
else:
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.lambda_bilinear * l2_loss(p1) + \
self.gamma_bilinear * l2_loss(q1)
def build_graph(self):
self._create_placeholder()
self._create_variable()
item_embs = tf.nn.embedding_lookup(self.item_embeddings,
self.item_seqs_ph) # (b,l,d)
user_emb = tf.nn.embedding_lookup(self.user_embeddings,
self.user_ph) # (b,d)
self._reg_loss += l2_loss(item_embs, user_emb)
union_out = self._forward(item_embs, user_emb) # (b,d)
train_ratings = self._train_rating(item_embs, user_emb,
union_out) # (b,2t)
pos_ratings, neg_ratings = tf.split(train_ratings,
[self.seq_T, self.seq_T],
axis=1)
loss = tf.reduce_sum(log_loss(pos_ratings - neg_ratings))
final_loss = loss + self.reg * self._reg_loss
train_opt = tf.train.AdamOptimizer(self.lr).minimize(final_loss)
weights = self.feature_gate_item.trainable_weights + self.feature_gate_user.trainable_weights
weights.extend([self.instance_gate_item, self.instance_gate_user])
with tf.control_dependencies([train_opt]):
self.train_opt = [
tf.assign(weight, tf.clip_by_norm(weight, 1.0))
for weight in weights
]
# for testing
self.bat_ratings = self._test_rating(item_embs, user_emb,
union_out) # (b,n)
def _create_loss(self):
with tf.name_scope("loss"):
self.pos_scores = tf.reduce_sum(tf.multiply(
self.u_g_embeddings, self.pos_i_g_embeddings),
axis=1)
neg_scores = tf.reduce_sum(tf.multiply(self.u_g_embeddings,
self.neg_i_g_embeddings),
axis=1)
embedding_regularizer = l2_loss(self.u_g_embeddings,
self.pos_i_g_embeddings,
self.neg_i_g_embeddings)
maxi = tf.nn.softplus(-(self.pos_scores - neg_scores))
mf_loss = tf.reduce_sum(maxi)
emb_loss = self.reg * embedding_regularizer
# for k in range(self.n_layers):
# emb_loss = emb_loss + self.reg_w*(tf.reduce_sum(tf.square(self.weights['W_gc_%d' % k])) +
# tf.reduce_sum(tf.square(self.weights['W_bi_%d' % k])) +
# tf.reduce_sum(tf.square(self.weights['b_gc_%d' % k])) +
# tf.reduce_sum(tf.square(self.weights['b_bi_%d' % k])))
self.loss = mf_loss + emb_loss
def build_graph(self):
self._create_variable()
# get embedding and bias
# b: batch size
# l1: the dim of the first layer
# ln: the dim of the last layer
# size_y: the length of Y_ph, i.e., n_sample+batch_size
cells = [tf.nn.rnn_cell.GRUCell(size, activation=self.hidden_act) for size in self.layers]
drop_cell = [tf.nn.rnn_cell.DropoutWrapper(cell) for cell in cells]
stacked_cell = tf.nn.rnn_cell.MultiRNNCell(drop_cell)
inputs = tf.nn.embedding_lookup(self.input_embeddings, self.X_ph) # (b, l1)
outputs, state = stacked_cell(inputs, state=self.state_ph)
self.u_emb = outputs # outputs: (b, ln)
self.final_state = state # [(b, l1), (b, l2), ..., (b, ln)]
# for training
items_embed = tf.nn.embedding_lookup(self.item_embeddings, self.Y_ph) # (size_y, ln)
items_bias = tf.gather(self.item_biases, self.Y_ph) # (size_y,)
logits = tf.matmul(outputs, items_embed, transpose_b=True) + items_bias # (b, size_y)
logits = self.final_act(logits)
loss = self.loss_fun(logits)
# reg loss
reg_loss = l2_loss(inputs, items_embed, items_bias)
final_loss = loss + self.reg*reg_loss
self.update_opt = tf.train.AdamOptimizer(self.lr).minimize(final_loss)
def _create_loss(self):
with tf.name_scope("loss"):
cost1 = tf.reduce_sum(self.pre_cost1) # prediction squared error
pre_cost2 = l2_loss(self.UW, self.UV, self.IW, self.IV, self.Ib1,
self.Ib2, self.Ub1, self.Ub2)
cost2 = self.reg * 0.5 * pre_cost2 # regularization term
self.cost = cost1 + cost2 # the loss function
def _create_loss(self):
with tf.name_scope("loss"):
self.loss = - tf.reduce_sum(self.input_R*tf.log(self.output) + (1 - self.input_R)*tf.log(1 - self.output))
self.reg_loss = self.reg * l2_loss(self.weights['encoder'], self.weights['decoder'],
self.biases['encoder'], self.biases['decoder'],
self.user_latent)
self.loss = self.loss + self.reg_loss
def _create_loss(self):
with tf.name_scope("loss"):
# loss for L(Theta)
# reg = l2_regularizer(self.reg_mf)
#
# reg_var = apply_regularization(reg, self.user_embedding + self.item_embedding)
self.loss = tf.losses.sigmoid_cross_entropy(self.labels, self.output) + \
self.reg_mf*l2_loss(self.latest_user_latent, self.latest_item_latent)
def __init__(self, sess, input_size, total_pasts, num_components,
component_size, belief_depth):
self.sess = sess
self.input_initializer = tf.placeholder(tf.float32, [1, input_size])
self.pasts_initializer = tf.placeholder(tf.float32,
[total_pasts, input_size])
self.input = tf.Variable(self.input_initializer,
trainable=False,
collections=[])
self.pasts = tf.Variable(self.pasts_initializer,
trainable=False,
collections=[])
self.generated_thoughts = tf.zeros([1, input_size], dtype=tf.float32)
self.backward_thoughts = tf.zeros([1, input_size], dtype=tf.float32)
self.improve_focus_operations = []
self.memorize_operations = []
self.reset_memory_operations = []
self.reseed_memory_operations = []
self.components = []
self.components.append(
temporal_lobe.Temporal_Component(component_size, input_size,
total_pasts, 3, "C"))
for i in xrange(1, num_components):
self.components.append(
lobe.Component(component_size, input_size, total_pasts,
belief_depth, "C" + str(i)))
for i in xrange(num_components):
u, v = self.components[i].build_graphs(
self.input,
tf.reshape(self.pasts, [-1, total_pasts * input_size]))
self.generated_thoughts = self.generated_thoughts + u
self.backward_thoughts = self.backward_thoughts + u
self.improve_focus_operations.append(
self.components[i].get_improve_focus_operation())
self.memorize_operations.append(
self.components[i].get_memorize_operation())
self.reset_memory_operations.append(
self.components[i].get_reset_memory_operation())
self.reseed_memory_operations.append(
self.components[i].get_reseed_memory_operation())
variables = [
var for var in tf.global_variables() if "content" in var.name
]
# print [var.name for var in variables]
self.learn_content_operation = util.l2_loss(self.backward_thoughts,
self.input,
variables,
rate=0.01)
self.saver = tf.train.Saver(keep_checkpoint_every_n_hours=1)
def __init__(self, item_num, user_num, emb_dim, lamda, param=None, init_delta=0.05, learning_rate=0.05):
self.itemNum = item_num
self.userNum = user_num
self.emb_dim = emb_dim
self.lamda = lamda # regularization parameters
self.param = param
self.init_delta = init_delta
self.learning_rate = learning_rate
self.d_params = []
with tf.variable_scope('discriminator'):
if self.param is None:
self.user_embeddings = tf.Variable(
tf.random_uniform([self.userNum, self.emb_dim], minval=-self.init_delta, maxval=self.init_delta,
dtype=tf.float32))
self.item_embeddings = tf.Variable(
tf.random_uniform([self.itemNum, self.emb_dim], minval=-self.init_delta, maxval=self.init_delta,
dtype=tf.float32))
self.item_bias = tf.Variable(tf.zeros([self.itemNum]))
else:
self.user_embeddings = tf.Variable(self.param[0])
self.item_embeddings = tf.Variable(self.param[1])
self.item_bias = tf.Variable(self.param[2])
self.d_params = [self.user_embeddings, self.item_embeddings, self.item_bias]
# placeholder definition
self.u = tf.placeholder(tf.int32)
self.i = tf.placeholder(tf.int32)
self.label = tf.placeholder(tf.float32)
self.u_embedding = tf.nn.embedding_lookup(self.user_embeddings, self.u)
self.i_embedding = tf.nn.embedding_lookup(self.item_embeddings, self.i)
self.i_bias = tf.gather(self.item_bias, self.i)
self.pre_logits = tf.reduce_sum(tf.multiply(self.u_embedding, self.i_embedding), 1) + self.i_bias
self.pre_loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=self.label, logits=self.pre_logits) + \
self.lamda * l2_loss(self.u_embedding, self.i_embedding, self.i_bias)
d_opt = tf.train.GradientDescentOptimizer(self.learning_rate)
self.d_updates = d_opt.minimize(self.pre_loss, var_list=self.d_params)
self.reward_logits = tf.reduce_sum(tf.multiply(self.u_embedding, self.i_embedding),
1) + self.i_bias
self.reward = 2 * (tf.sigmoid(self.reward_logits) - 0.5)
# for test stage, self.u: [batch_size]
self.all_rating = tf.matmul(self.u_embedding, self.item_embeddings, transpose_b=True) + self.item_bias
self.all_logits = tf.reduce_sum(tf.multiply(self.u_embedding, self.item_embeddings), 1) + self.item_bias
self.NLL = -tf.reduce_mean(tf.log(
tf.gather(tf.reshape(tf.nn.softmax(tf.reshape(self.all_logits, [1, -1])), [-1]), self.i))
)
# for dns sample
self.dns_rating = tf.reduce_sum(tf.multiply(self.u_embedding, self.item_embeddings), 1) + self.item_bias
def create_bpr_loss(self, users, pos_items, neg_items):
pos_scores = inner_product(users, pos_items)
neg_scores = inner_product(users, neg_items)
regularizer = l2_loss(self.u_g_embeddings_pre,
self.pos_i_g_embeddings_pre,
self.neg_i_g_embeddings_pre)
mf_loss = tf.reduce_sum(log_loss(pos_scores - neg_scores))
emb_loss = self.reg * regularizer
return mf_loss, emb_loss
def _create_loss(self):
with tf.name_scope("loss"):
# loss for L(Theta)
p1, q1, b1, self.output = self._create_inference(
self.item_input_pos)
_, q2, b2, output_social = self._create_inference(
self.item_input_social)
_, q3, b3, output_neg = self._create_inference(self.item_input_neg)
result1 = tf.divide(self.output - output_social, self.suk)
result2 = output_social - output_neg
self.loss = learner.pairwise_loss(self.loss_function, result1) + \
learner.pairwise_loss(self.loss_function, result2) + \
self.reg_mf * l2_loss(p1, q2, q1, q3, b1, b2, b3)
def _create_loss(self):
with tf.name_scope("loss"):
# BPR loss for L(Theta)
self.p1, self.q1, self.output = self._create_inference(
self.item_input_pos)
self.p2, self.q2, self.output_neg = self._create_inference(
self.item_input_neg)
self.result = self.output - self.output_neg
self.loss = learner.pairwise_loss(self.loss_function, self.result)
self.opt_loss = self.loss + self.lambda_bilinear * l2_loss(self.p1, self.q2, self.q1) + \
self.gamma_bilinear * self._regular([(self.W, self.b)]) + \
self.lambda_weight * (self._regular(self.P) + self._regular([(self.W, self.b)]))
def _create_loss(self):
with tf.name_scope("loss"):
self.output = tf.reduce_sum(tf.multiply(self.u_embeddings,
self.pos_i_embeddings),
axis=1)
output_neg = tf.reduce_sum(tf.multiply(self.u_embeddings,
self.neg_j_embeddings),
axis=1)
regularizer = self.reg * l2_loss(self.u_embeddings,
self.pos_i_embeddings,
self.neg_j_embeddings)
self.loss = learner.pairwise_loss(
self.loss_function, self.output - output_neg) + regularizer
def __init__(self, item_num, user_num, emb_dim, lamda, param=None, init_delta=0.05, learning_rate=0.05):
self.itemNum = item_num
self.userNum = user_num
self.emb_dim = emb_dim
self.lamda = lamda # regularization parameters
self.param = param
self.init_delta = init_delta
self.learning_rate = learning_rate
self.g_params = []
with tf.variable_scope('generator'):
if self.param is None:
self.user_embeddings = tf.Variable(
tf.random_uniform([self.userNum, self.emb_dim], minval=-self.init_delta, maxval=self.init_delta,
dtype=tf.float32))
self.item_embeddings = tf.Variable(
tf.random_uniform([self.itemNum, self.emb_dim], minval=-self.init_delta, maxval=self.init_delta,
dtype=tf.float32))
self.item_bias = tf.Variable(tf.zeros([self.itemNum]))
else:
self.user_embeddings = tf.Variable(self.param[0])
self.item_embeddings = tf.Variable(self.param[1])
self.item_bias = tf.Variable(param[2])
self.g_params = [self.user_embeddings, self.item_embeddings, self.item_bias]
self.u = tf.placeholder(tf.int32)
self.i = tf.placeholder(tf.int32)
self.reward = tf.placeholder(tf.float32)
self.u_embedding = tf.nn.embedding_lookup(self.user_embeddings, self.u)
self.i_embedding = tf.nn.embedding_lookup(self.item_embeddings, self.i)
self.i_bias = tf.gather(self.item_bias, self.i)
self.all_logits = tf.reduce_sum(tf.multiply(self.u_embedding, self.item_embeddings), 1) + self.item_bias
self.i_prob = tf.gather(
tf.reshape(tf.nn.softmax(tf.reshape(self.all_logits, [1, -1])), [-1]),
self.i)
self.gan_loss = -tf.reduce_mean(tf.log(self.i_prob) * self.reward) + \
self.lamda * l2_loss(self.u_embedding, self.i_embedding, self.i_bias)
g_opt = tf.train.GradientDescentOptimizer(self.learning_rate)
self.gan_updates = g_opt.minimize(self.gan_loss, var_list=self.g_params)
# for test stage, self.u: [batch_size]
self.all_rating = tf.matmul(self.u_embedding, self.item_embeddings, transpose_a=False,
transpose_b=True) + self.item_bias
def _create_loss(self):
with tf.name_scope("loss"):
# loss for L(Theta)
self.output = self._create_inference(self.item_input_pos)
self.output_neg = self._create_inference(self.item_input_neg)
self.result = self.output - self.output_neg
# self.loss = tf.reduce_sum(tf.log(1 + tf.exp(-self.result))) # this is numerically unstable
self.loss = tf.reduce_sum(tf.nn.softplus(-self.result))
# loss to be omptimized
self.opt_loss = self.loss + self.reg * l2_loss(
self.embedding_P, self.embedding_Q)
if self.adver:
# loss for L(Theta + adv_Delta)
self.output_adv = self._create_inference_adv(
self.item_input_pos)
self.output_neg_adv = self._create_inference_adv(
self.item_input_neg)
self.result_adv = self.output_adv - self.output_neg_adv
# self.loss_adv = tf.reduce_sum(tf.log(1 + tf.exp(-self.result_adv)))
self.loss_adv = tf.reduce_sum(tf.nn.softplus(-self.result_adv))
self.opt_loss += self.reg_adv * self.loss_adv
def _train_rating(self, item_embs, user_emb, union_out):
w2 = tf.nn.embedding_lookup(self.W2, self.predict_item) # (b,2t,d)
b2 = tf.gather(self.b2, self.predict_item) # (b,2t)
self._reg_loss += l2_loss(w2, b2)
# MF
term3 = tf.squeeze(tf.matmul(w2, tf.expand_dims(
user_emb, axis=2))) # (b,2t,d)x(b,d,1)->(b,2t,1)->(b,2t)
res = b2 + term3 # (b,2t)
# union-level
term4 = tf.matmul(tf.expand_dims(union_out, axis=1),
w2,
transpose_b=True) # (b,1,d)x(b,d,2l)->(b,1,2l)
res += tf.squeeze(term4) # (b,2t)
# item-item product
rel_score = tf.matmul(item_embs, w2,
transpose_b=True) # (b,l,d)x(b,d,2t)->(b,l,2t)
rel_score = tf.reduce_sum(rel_score, axis=1) # (b,2t)
res += rel_score # (b,2t)
return res
def build_graph(self):
self._create_variable()
hidden_ori = self._encoding(self.users_ph, self.sp_mat_ph) # (b,d)
# decoding
de_item_embs = tf.nn.embedding_lookup(self.de_embeddings,
self.items_ph) # (l,d)
de_bias = tf.gather(self.de_bias, self.items_ph) # (l,d)
hidden = tf.nn.embedding_lookup(hidden_ori, self.remap_idx_ph)
ratings = inner_product(hidden, de_item_embs) + de_bias
# reg loss
item_ids, _ = tf.unique(self.items_ph)
reg_loss = l2_loss(
tf.nn.embedding_lookup(self.en_embeddings, item_ids),
self.en_offset,
tf.nn.embedding_lookup(self.user_embeddings, self.users_ph),
tf.nn.embedding_lookup(self.de_embeddings, item_ids),
tf.gather(self.de_bias, item_ids))
if self.loss_func == "square":
model_loss = tf.squared_difference(ratings, self.labels_ph)
elif self.loss_func == "sigmoid_cross_entropy":
model_loss = tf.nn.sigmoid_cross_entropy_with_logits(
logits=ratings, labels=self.labels_ph)
else:
raise ValueError("%s is an invalid loss function." %
self.loss_func)
final_loss = tf.reduce_sum(model_loss) + self.reg * reg_loss
self.train_opt = tf.train.AdamOptimizer(self.lr).minimize(
final_loss, name="train_opt")
# for evaluation
self.batch_ratings = tf.matmul(
hidden_ori, self.de_embeddings, transpose_b=True) + self.de_bias
def create_bpr_loss(self):
batch_u_embeddings = tf.nn.embedding_lookup(self.ua_embeddings,
self.users)
batch_pos_i_embeddings = tf.nn.embedding_lookup(
self.ia_embeddings, self.pos_items)
batch_neg_i_embeddings = tf.nn.embedding_lookup(
self.ia_embeddings, self.neg_items)
batch_u_embeddings_pre = tf.nn.embedding_lookup(
self.weights['user_embedding'], self.users)
batch_pos_i_embeddings_pre = tf.nn.embedding_lookup(
self.weights['item_embedding'], self.pos_items)
batch_neg_i_embeddings_pre = tf.nn.embedding_lookup(
self.weights['item_embedding'], self.neg_items)
regularizer = l2_loss(batch_u_embeddings_pre,
batch_pos_i_embeddings_pre,
batch_neg_i_embeddings_pre)
emb_loss = self.reg * regularizer
pos_scores = inner_product(batch_u_embeddings, batch_pos_i_embeddings)
neg_scores = inner_product(batch_u_embeddings, batch_neg_i_embeddings)
bpr_loss = tf.reduce_sum(log_loss(pos_scores - neg_scores))
# self.score_sigmoid = tf.sigmoid(pos_scores)
self.grad_score = 1 - tf.sigmoid(pos_scores - neg_scores)
self.grad_user_embed = (
1 - tf.sigmoid(pos_scores - neg_scores)) * tf.sqrt(
tf.reduce_sum(tf.multiply(batch_u_embeddings,
batch_u_embeddings),
axis=1))
self.grad_item_embed = (
1 - tf.sigmoid(pos_scores - neg_scores)) * tf.sqrt(
tf.reduce_sum(tf.multiply(batch_pos_i_embeddings,
batch_pos_i_embeddings),
axis=1))
return bpr_loss, emb_loss
def build_graph(self):
'''
*********************************************************
Create Placeholder for Input Data & Dropout.
'''
# placeholder definition
self.users_ph = tf.placeholder(tf.int32, shape=(None, ))
self.pos_items_ph = tf.placeholder(tf.int32, shape=(None, ))
self.anchor = tf.placeholder(tf.float32,
shape=(self.localmodel, self.localmodel))
for i in range(self.localmodel):
exec(
"self.model_adj%d = tf.sparse_placeholder(tf.float32,name='model_adj%d')"
% (i, i))
self.node_dropout_ph = tf.placeholder(tf.float32, shape=[None])
self.mess_dropout_ph = tf.placeholder(tf.float32, shape=[None])
"""
*********************************************************
Create Model Parameters (i.e., Initialize Weights).
"""
# initialization of model parameters
self.weights = self._init_weights()
self._init_constant()
"""
*********************************************************
Compute Graph-based Representations of all users & items via Message-Passing Mechanism of Graph Neural Networks.
Different Convolutional Layers:
1. ngcf: defined in 'Neural Graph Collaborative Filtering', SIGIR2019;
2. gcn: defined in 'Semi-Supervised Classification with Graph Convolutional Networks', ICLR2018;
3. gcmc: defined in 'Graph Convolutional Matrix Completion', KDD2018;
"""
ego_embeddings = tf.concat(
[self.weights['user_embedding'], self.weights['item_embedding']],
axis=0)
for n_cluster in range(self.localmodel):
self.all_embeddings_temp = self._create_lightgcn_embed(
self.norm_adj[n_cluster], ego_embeddings)
if n_cluster == 0:
self.all_embeddings = [self.all_embeddings_temp]
continue
self.all_embeddings += [self.all_embeddings_temp]
self.all_embeddings = tf.stack(self.all_embeddings, 1)
self.latent = tf.reduce_mean(self.all_embeddings,
axis=0,
keepdims=False)
self.all_embeddings = tf.reduce_mean(self.all_embeddings,
axis=1,
keepdims=False)
# self.all_embeddings = tf.reduce_max(self.all_embeddings, reduction_indices=[1])
self.ua_embeddings, self.ia_embeddings = tf.split(
tf.reshape(self.all_embeddings,
(self.n_users + self.n_items, self.emb_dim)),
[self.n_users, self.n_items], 0)
local_embeddings = tf.concat([
self.weights['local_user_embedding'],
self.weights['local_item_embedding']
],
axis=0)
for n_cluster in range(self.localmodel):
self.local_embeddings_temp = self._create_lightgcn_embed(
self.norm_adj[n_cluster], local_embeddings)
if n_cluster == 0:
self.local_embeddings_all = [self.local_embeddings_temp]
continue
self.local_embeddings_all += [self.local_embeddings_temp]
self.local_embeddings_all = tf.stack(self.local_embeddings_all, 0)
self.local_embeddings_all = tf.matmul(
self.anchor,
tf.reshape(self.local_embeddings_all, [self.localmodel, -1]))
self.local_embeddings_all = tf.reduce_mean(self.local_embeddings_all,
axis=0,
keepdims=False)
self.local_u, self.local_i = tf.split(
tf.reshape(self.local_embeddings_all,
(self.n_users + self.n_items, self.emb_dim)),
[self.n_users, self.n_items], 0)
"""
*********************************************************
Inference for the testing phase.
"""
# for prediction
self.item_embeddings_final = tf.Variable(tf.zeros(
[self.n_items, self.emb_dim]),
dtype=tf.float32,
name="item_embeddings_final",
trainable=False)
self.user_embeddings_final = tf.Variable(tf.zeros(
[self.n_users, self.emb_dim]),
dtype=tf.float32,
name="user_embeddings_final",
trainable=False)
self.assign_opt = [
tf.assign(self.user_embeddings_final, self.ua_embeddings),
tf.assign(self.item_embeddings_final, self.ia_embeddings)
]
u_embed = tf.nn.embedding_lookup(self.user_embeddings_final,
self.users_ph)
self.batch_ratings = tf.matmul(u_embed,
self.item_embeddings_final,
transpose_a=False,
transpose_b=True)
self.u_g_embeddings_pre = tf.nn.embedding_lookup(
self.weights['user_embedding'], self.user_idx)
self.i_g_embeddings_pre = tf.nn.embedding_lookup(
self.weights['item_embedding'], self.item_idx)
"""
*********************************************************
Generate Predictions & Optimize via fast loss.
"""
term1 = tf.matmul(self.ua_embeddings,
self.ua_embeddings,
transpose_a=True)
term2 = tf.matmul(self.ia_embeddings,
self.ia_embeddings,
transpose_a=True)
loss1 = tf.reduce_sum(tf.multiply(term1, term2))
user_embed = tf.nn.embedding_lookup(self.ua_embeddings, self.user_idx)
item_embed = tf.nn.embedding_lookup(self.ia_embeddings, self.item_idx)
pos_ratings = inner_product(user_embed, item_embed)
loss1 += tf.reduce_sum((self.r_alpha - 1) * tf.square(pos_ratings) -
2.0 * self.r_alpha * pos_ratings)
# reg
reg_loss = l2_loss(self.u_g_embeddings_pre, self.i_g_embeddings_pre)
self.loss = loss1 + self.fast_reg * reg_loss
self.opt = tf.train.AdagradOptimizer(learning_rate=self.lr).minimize(
self.loss)
self.local_u_pre = tf.nn.embedding_lookup(
self.weights['local_user_embedding'], self.user_idx)
self.local_i_pre = tf.nn.embedding_lookup(
self.weights['local_item_embedding'], self.item_idx)
local_term1 = tf.matmul(self.local_u, self.local_u, transpose_a=True)
local_term2 = tf.matmul(self.local_i, self.local_i, transpose_a=True)
loss2 = tf.reduce_sum(tf.multiply(local_term1, local_term2))
local_user_embed = tf.nn.embedding_lookup(self.local_u, self.user_idx)
local_item_embed = tf.nn.embedding_lookup(self.local_i, self.item_idx)
local_pos_ratings = inner_product(local_user_embed, local_item_embed)
loss2 += tf.reduce_sum((self.r_alpha - 1) *
tf.square(local_pos_ratings) -
2.0 * self.r_alpha * local_pos_ratings)
# reg
reg_loss = l2_loss(self.local_u_pre, self.local_i_pre)
self.local_loss = loss2 + self.fast_reg * reg_loss
self.local_opt = tf.train.AdagradOptimizer(
learning_rate=self.lr).minimize(self.local_loss)
def build_graph(self):
'''
*********************************************************
Create Placeholder for Input Data & Dropout.
'''
# placeholder definition
self.users_ph = tf.placeholder(tf.int32, shape=(None, ))
self.pos_items_ph = tf.placeholder(tf.int32, shape=(None, ))
self.neg_items_ph = tf.placeholder(tf.int32, shape=(None, ))
# dropout: node dropout (adopted on the ego-networks);
# ... since the usage of node dropout have higher computational cost,
# ... please use the 'node_dropout_flag' to indicate whether use such technique.
# message dropout (adopted on the convolution operations).
self.node_dropout_ph = tf.placeholder(tf.float32, shape=[None])
self.mess_dropout_ph = tf.placeholder(tf.float32, shape=[None])
"""
*********************************************************
Create Model Parameters (i.e., Initialize Weights).
"""
# initialization of model parameters
self.weights = self._init_weights()
self._init_constant()
"""
*********************************************************
Compute Graph-based Representations of all users & items via Message-Passing Mechanism of Graph Neural Networks.
Different Convolutional Layers:
1. ngcf: defined in 'Neural Graph Collaborative Filtering', SIGIR2019;
2. gcn: defined in 'Semi-Supervised Classification with Graph Convolutional Networks', ICLR2018;
3. gcmc: defined in 'Graph Convolutional Matrix Completion', KDD2018;
"""
if self.alg_type in ['lightgcn']:
self.ego_embeddings = tf.concat([
self.weights['user_embedding'], self.weights['item_embedding']
],
axis=0)
self.all_embeddings = self._create_lightgcn_embed(
self.ego_embeddings)
self.ua_embeddings, self.ia_embeddings = tf.split(
self.all_embeddings, [self.n_users, self.n_items], 0)
elif self.alg_type in ['ngcf']:
self.ua_embeddings, self.ia_embeddings = self._create_ngcf_embed()
elif self.alg_type in ['gcn']:
self.ua_embeddings, self.ia_embeddings = self._create_gcn_embed()
elif self.alg_type in ['gcmc']:
self.ua_embeddings, self.ia_embeddings = self._create_gcmc_embed()
"""
*********************************************************
Inference for the testing phase.
"""
# for prediction
self.item_embeddings_final = tf.Variable(tf.zeros(
[self.n_items, self.emb_dim]),
dtype=tf.float32,
name="item_embeddings_final",
trainable=False)
self.user_embeddings_final = tf.Variable(tf.zeros(
[self.n_users, self.emb_dim]),
dtype=tf.float32,
name="user_embeddings_final",
trainable=False)
self.assign_opt = [
tf.assign(self.user_embeddings_final, self.ua_embeddings),
tf.assign(self.item_embeddings_final, self.ia_embeddings)
]
self.emb = tf.concat(
[self.user_embeddings_final, self.item_embeddings_final], 0)
u_embed = tf.nn.embedding_lookup(self.user_embeddings_final,
self.users_ph)
self.batch_ratings = tf.matmul(u_embed,
self.item_embeddings_final,
transpose_a=False,
transpose_b=True)
self.u_g_embeddings_pre = tf.nn.embedding_lookup(
self.weights['user_embedding'], self.user_idx)
self.i_g_embeddings_pre = tf.nn.embedding_lookup(
self.weights['item_embedding'], self.item_idx)
"""
*********************************************************
Generate Predictions & Optimize via BPR loss.
"""
# rating
term1 = tf.matmul(self.ua_embeddings,
self.ua_embeddings,
transpose_a=True)
term2 = tf.matmul(self.ia_embeddings,
self.ia_embeddings,
transpose_a=True)
loss1 = tf.reduce_sum(tf.multiply(term1, term2))
user_embed = tf.nn.embedding_lookup(self.ua_embeddings, self.user_idx)
item_embed = tf.nn.embedding_lookup(self.ia_embeddings, self.item_idx)
pos_ratings = inner_product(user_embed, item_embed)
loss1 += tf.reduce_sum((self.r_alpha - 1) * tf.square(pos_ratings) -
2.0 * self.r_alpha * pos_ratings)
# reg
reg_loss = l2_loss(self.u_g_embeddings_pre, self.i_g_embeddings_pre)
self.loss = loss1 + self.fast_reg * reg_loss
# self.opt = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(loss)
self.opt = tf.train.AdagradOptimizer(learning_rate=self.lr).minimize(
self.loss)
def _create_loss(self):
with tf.name_scope("loss"):
UI_u, IU_i, LI_l, self.output = self._create_inference()
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.reg * l2_loss(UI_u, IU_i, LI_l)
def _regular(self, params):
res = 0
for param in params:
res += l2_loss(param[0], param[1])
return res
def _create_loss(self):
with tf.name_scope("loss"):
# loss for L(Theta)
p1, q1, r1, self.output = self._create_inference()
self.loss = learner.pointwise_loss(self.loss_function, self.labels, self.output) + \
self.reg_mf * l2_loss(p1, r1, q1)
#!/usr/local/bin/python
