def _build_training_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
if self._extra is not None:
in_tensor = tf.concat([self._user, self._item, self._extra],
axis=1)
else:
in_tensor = tf.concat([self._user, self._item], axis=1)
reg = MultiLayerFC(in_tensor=in_tensor,
dims=self._dims,
bias_in=True,
bias_mid=True,
bias_out=False,
dropout_mid=self._dropout,
l2_reg=self._l2_reg,
scope='mlp_reg',
reuse=self._reuse)
logits = reg.get_outputs()[0]
if self._item_bias is not None:
logits += self._item_bias
labels_float = tf.reshape(tf.to_float(self._labels), (-1, 1))
self._loss = tf.reduce_sum(
tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_float,
logits=logits))
self._outputs.append(logits)
def PointwiseMLPCE(
user,
item,
dims,
subgraph,
item_bias=None,
extra=None,
l2_reg=None,
labels=None,
dropout=None,
train=None,
scope=None,
):
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
if extra is not None:
in_tensor = tf.concat([user, item, extra], axis=1)
else:
in_tensor = tf.concat([user, item], axis=1)
if train:
reg = MultiLayerFC(
in_tensor=in_tensor,
dims=dims,
subgraph=subgraph,
bias_in=True,
bias_mid=True,
bias_out=False,
dropout_mid=dropout,
l2_reg=l2_reg,
scope="mlp_reg",
)
else:
reg = MultiLayerFC(
in_tensor=in_tensor,
dims=dims,
subgraph=subgraph,
bias_in=True,
bias_mid=True,
bias_out=False,
l2_reg=l2_reg,
scope="mlp_reg",
)
logits = reg # .get_outputs()[0]
if item_bias is not None:
logits += item_bias
if train:
labels_float = tf.reshape(tf.to_float(labels), (-1, 1))
subgraph.register_global_loss(
tf.reduce_sum(
tf.nn.sigmoid_cross_entropy_with_logits(
labels=labels_float, logits=logits)))
subgraph.register_global_output(logits)
else:
subgraph.register_global_output(tf.sigmoid(logits))
def MLPSoftmax(user,
item,
seq_len,
max_seq_len,
dims,
subgraph,
item_bias=None,
extra=None,
l2_reg=None,
labels=None,
dropout=None,
train=None,
scope=None):
with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
# average item vectors user interacted with
seq_mask = tf.sequence_mask(seq_len, max_seq_len, dtype=tf.float32)
item = tf.reduce_mean(item * tf.expand_dims(seq_mask, axis=2), axis=1)
if user is not None:
in_tensor = tf.concat([user, item], axis=1)
else:
in_tensor = tf.concat([item], axis=1)
if extra is not None:
in_tensor = tf.concat([in_tensor, extra], axis=1)
if train:
logits = MultiLayerFC(in_tensor=in_tensor,
dims=dims,
subgraph=subgraph,
bias_in=True,
bias_mid=True,
bias_out=False,
dropout_mid=dropout,
l2_reg=l2_reg,
scope='mlp_reg')
else:
logits = MultiLayerFC(in_tensor=in_tensor,
dims=dims,
subgraph=subgraph,
bias_in=True,
bias_mid=True,
bias_out=False,
l2_reg=l2_reg,
scope='mlp_reg')
if item_bias is not None:
logits += item_bias
if train:
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels, logits=logits)
subgraph.register_global_loss(tf.reduce_mean(loss))
else:
subgraph.register_global_output(logits)
def _build_shared_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
_encoder = MultiLayerFC(l2_reg=self._l2_reg,
in_tensor=self._in_tensor,
dims=self._dims[1:],
scope='encoder',
dropout_in=self._dropout,
dropout_mid=self._dropout,
reuse=self._reuse)
_decoder = MultiLayerFC(l2_reg=self._l2_reg,
in_tensor=_encoder.get_outputs()[0],
dims=self._dims[::-1][1:],
scope='decoder',
relu_in=True,
dropout_in=self._dropout,
relu_mid=True,
dropout_mid=self._dropout,
relu_out=True,
dropout_out=self._dropout,
reuse=self._reuse)
self._outputs += _encoder.get_outputs()
self._loss = _encoder.get_loss() + _decoder.get_loss()
self._loss += self._l2_reconst * tf.nn.l2_loss(
_decoder.get_outputs()[0] - self._in_tensor)
def _build_item_extractions(self, train=True):
super(VisualBPR, self)._build_item_extractions(train)
if train:
self._p_item_vf = MultiLayerFC(in_tensor=self._p_item_vfeature_input, dropout_mid=self._dropout_rate,
dims=self._dims, scope='item_visual_embed', reuse=False)
self._n_item_vf = MultiLayerFC(in_tensor=self._n_item_vfeature_input, dropout_mid=self._dropout_rate,
dims=self._dims, scope='item_visual_embed', reuse=True)
self._loss_nodes += [self._p_item_vf, self._n_item_vf]
else:
self._item_vf_serving = MultiLayerFC(in_tensor=self._item_vfeature_serving,
dims=self._dims, scope='item_visual_embed', reuse=True)
def _build_item_extractions(self, train=True):
super(VisualBPR, self)._build_item_extractions(train)
if train:
self._add_module('p_item_vf',
MultiLayerFC(in_tensor=self._get_input('p_item_vfeature'), dropout_mid=self._dropout_rate, train=True,
l2_reg=self._l2_reg_mlp, dims=self._dims, scope='item_visual_embed', reuse=False))
self._add_module('n_item_vf',
MultiLayerFC(in_tensor=self._get_input('n_item_vfeature'), dropout_mid=self._dropout_rate, train=True,
l2_reg=self._l2_reg_mlp, dims=self._dims, scope='item_visual_embed', reuse=True))
else:
self._add_module('item_vf',
MultiLayerFC(in_tensor=self._get_input('item_vfeature', train=False), train=False,
l2_reg=self._l2_reg_mlp, dims=self._dims, scope='item_visual_embed', reuse=True),
train=False)
def train_add_item_graph(subgraph):
p_item_vout = MultiLayerFC(in_tensor=subgraph['p_item_vfeature'],
l2_reg=l2_reg_mlp,
subgraph=subgraph,
dims=[dim_user_embed - dim_item_embed],
scope='item_MLP')
n_item_vout = MultiLayerFC(in_tensor=subgraph['n_item_vfeature'],
l2_reg=l2_reg_mlp,
subgraph=subgraph,
dims=[dim_user_embed - dim_item_embed],
scope='item_MLP')
subgraph['p_item_vec'] = tf.concat(
[subgraph['p_item_vec'], p_item_vout], axis=1)
subgraph['n_item_vec'] = tf.concat(
[subgraph['n_item_vec'], n_item_vout], axis=1)
def _build_item_extractions(self, train=True):
super(ConcatVisualBPR, self)._build_item_extractions(train)
if train:
self._loss_nodes.remove(self._p_item_vec)
self._loss_nodes.remove(self._n_item_vec)
self._p_item_lf = LatentFactor(
init='normal',
l2_reg=self._l2_reg,
ids=self._p_item_id_input,
shape=[self._max_item, self._dim_embed - self._dim_ve],
scope='item',
reuse=False)
self._p_item_vf = MultiLayerFC(
in_tensor=self._p_item_vfeature_input,
dims=[self._dim_ve],
scope='item_MLP',
reuse=False)
self._n_item_lf = LatentFactor(
init='normal',
l2_reg=self._l2_reg,
ids=self._n_item_id_input,
shape=[self._max_item, self._dim_embed - self._dim_ve],
scope='item',
reuse=True)
self._n_item_vf = MultiLayerFC(
in_tensor=self._n_item_vfeature_input,
dims=[self._dim_ve],
scope='item_MLP',
reuse=True)
else:
self._item_lf_serving = LatentFactor(
init='normal',
l2_reg=self._l2_reg,
ids=self._item_id_serving,
shape=[self._max_item, self._dim_embed - self._dim_ve],
scope='item',
reuse=True)
self._item_vf_serving = MultiLayerFC(
in_tensor=self._item_vfeature_serving,
dims=[self._dim_ve],
scope='item_MLP',
reuse=True)
def _build_serving_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
user_rep = tf.reshape(tf.tile(self._user, [1, tf.shape(self._item)[0]]), (-1, tf.shape(self._user)[1]))
item_rep = tf.tile(self._item, (tf.shape(self._user)[0], 1))
item_bias_rep = tf.tile(self._item_bias, (tf.shape(self._user)[0], 1))
in_tensor = tf.concat([user_rep, item_rep], axis=1)
reg = MultiLayerFC(
in_tensor=in_tensor,
dims=self._dims,
bias_in=True,
bias_mid=True,
bias_out=False,
l2_reg=self._l2_reg,
scope='mlp_reg',
reuse=self._reuse)
self._outputs.append(tf.reshape(reg.get_outputs()[0] + item_bias_rep, (tf.shape(self._user)[0], tf.shape(self._item)[0])))
def _build_user_extractions(self, train=True):
super(UserVisualPMF, self)._build_user_extractions(train)
self._add_module('user_f',
MultiLayerFC(in_tensor=self._get_input('user_feature', train=train), train=train,
dims=self._dims_user, l2_reg=self._l2_reg_mlp, dropout_mid=self._dropout_rate,
scope='user_MLP', reuse=not train),
train=train)
def _build_training_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
pointwise_product = tf.multiply(self._user, self._item)
gdp = MultiLayerFC(in_tensor=pointwise_product,
dims=[1],
bias_in=False,
bias_mid=False,
bias_out=False,
l2_reg=self._l2_reg,
scope='gmf_reg',
reuse=self._reuse)
logits = gdp.get_outputs()[0] + self._item_bias
labels_float = tf.reshape(tf.to_float(self._labels), (-1, 1))
self._loss = tf.reduce_sum(
tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_float,
logits=logits))
self._outputs.append(logits)
def serving_add_item_graph(subgraph):
item_vout = MultiLayerFC(
in_tensor=subgraph["item_vfeature"],
l2_reg=l2_reg_mlp,
subgraph=subgraph,
dims=[dim_user_embed - dim_item_embed],
scope="item_MLP",
)
subgraph["item_vec"] = tf.concat([subgraph["item_vec"], item_vout],
axis=1)
def _build_item_extractions(self, train=True):
super(VisualPMF, self)._build_item_extractions(train)
if train:
self._item_vf = MultiLayerFC(in_tensor=self._item_vfeature_input,
dims=self._dims,
l2_reg=self._l2_reg_mlp,
dropout_mid=self._dropout_rate,
scope='item_MLP',
reuse=False)
self._loss_nodes += [self._item_vf]
else:
self._item_vf_serving = MultiLayerFC(
in_tensor=self._item_vfeature_serving,
dims=self._dims,
l2_reg=self._l2_reg_mlp,
dropout_mid=self._dropout_rate,
scope='item_MLP',
reuse=True)
def _build_user_extractions(self, train=True):
super(UserPMF, self)._build_user_extractions(train)
if train:
self._loss_nodes.remove(self._user_vec)
self._user_f = MultiLayerFC(in_tensor=self._user_feature_input,
dims=self._dims,
l2_reg=self._l2_reg_mlp,
dropout_mid=self._dropout_rate,
scope='user_MLP',
reuse=False)
else:
self._user_f_serving = MultiLayerFC(
in_tensor=self._user_feature_serving,
dims=self._dims,
l2_reg=self._l2_reg_mlp,
dropout_mid=self._dropout_rate,
scope='user_MLP',
reuse=True)
def _build_serving_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
user_rep = tf.reshape(
tf.tile(self._user, [1, tf.shape(self._item)[0]]),
(-1, tf.shape(self._user)[1]))
item_rep = tf.tile(self._item, (tf.shape(self._user)[0], 1))
item_bias_rep = tf.tile(self._item_bias,
(tf.shape(self._user)[0], 1))
pointwise_product = tf.multiply(user_rep, item_rep)
gdp = MultiLayerFC(in_tensor=pointwise_product,
dims=[1],
bias_in=False,
bias_mid=False,
bias_out=False,
l2_reg=self._l2_reg,
scope='gmf_reg',
reuse=self._reuse)
self._outputs.append(
tf.reshape(gdp.get_outputs()[0] + item_bias_rep,
(tf.shape(self._user)[0], tf.shape(self._item)[0])))
def _build_training_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
if self._mlp_pretrain:
self._pretrain_input = tf.placeholder(tf.float32,
shape=(32,
self._shape[1]),
name='pretrain_input')
trans_embedding = MultiLayerFC(in_tensor=self._pretrain_input,
dims=self._mlp_dims,
batch_norm=True,
scope=self._scope + '/MLP',
train=True,
reuse=True,
l2_reg=self._l2_reg,
relu_out=True)
identity_loss = tf.nn.l2_loss(
trans_embedding.get_outputs()[0] - self._pretrain_input)
self._pretrain_ops = tf.train.AdamOptimizer(
learning_rate=0.001).minimize(identity_loss)
def _build_serving_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
if self._batch_serving:
user_rep = tf.reshape(
tf.tile(self._user, [1, tf.shape(self._item)[0]]),
(-1, tf.shape(self._user)[1]))
item_rep = tf.tile(self._item, (tf.shape(self._user)[0], 1))
if self._extra is not None:
extra_rep = tf.tile(self._extra,
(tf.shape(self._user)[0], 1))
in_tensor = tf.concat([user_rep, item_rep, extra_rep],
axis=1)
else:
in_tensor = tf.concat([user_rep, item_rep], axis=1)
reg = MultiLayerFC(in_tensor=in_tensor,
dims=self._dims,
bias_in=True,
bias_mid=True,
bias_out=False,
l2_reg=self._l2_reg,
scope='mlp_reg',
reuse=self._reuse)
if self._item_bias is not None:
item_bias_rep = tf.tile(self._item_bias,
(tf.shape(self._user)[0], 1))
self._outputs.append(
tf.reshape(reg.get_outputs()[0] + item_bias_rep,
(tf.shape(self._user)[0],
tf.shape(self._item)[0])))
else:
self._outputs.append(
tf.reshape(reg.get_outputs()[0], (tf.shape(
self._user)[0], tf.shape(self._item)[0])))
else:
if self._extra is not None:
in_tensor = tf.concat(
[self._user, self._item, self._extra], axis=1)
else:
in_tensor = tf.concat([self._user, self._item], axis=1)
reg = MultiLayerFC(in_tensor=in_tensor,
dims=self._dims,
bias_in=True,
bias_mid=True,
bias_out=False,
l2_reg=self._l2_reg,
scope='mlp_reg',
reuse=self._reuse)
logits = reg.get_outputs()[0]
if self._item_bias is not None:
logits += self._item_bias
self._outputs.append(tf.sigmoid(logits))
def _build_shared_graph(self):
with tf.variable_scope(self._scope, reuse=self._reuse):
self._embedding = tf.get_variable('embedding',
dtype=tf.float32,
shape=self._shape,
trainable=False,
initializer=self._initializer)
self._flag = tf.get_variable('flag',
dtype=tf.bool,
shape=[self._shape[0]],
trainable=False,
initializer=tf.constant_initializer(
value=False, dtype=tf.bool))
unique_ids, _ = tf.unique(self._ids)
with tf.control_dependencies([
tf.scatter_update(self._flag, unique_ids,
tf.ones_like(unique_ids, dtype=tf.bool))
]):
trans_embedding = MultiLayerFC(
in_tensor=tf.nn.embedding_lookup(self._embedding,
self._ids),
dims=self._mlp_dims,
batch_norm=True,
scope=self._scope + '/MLP',
train=self._train,
reuse=self._reuse,
l2_reg=self._l2_reg,
relu_out=True)
self._outputs += trans_embedding.get_outputs()
self._loss += trans_embedding.get_loss()
update_ids = tf.reshape(tf.where(self._flag), [-1])
update_embedding = MultiLayerFC(in_tensor=tf.nn.embedding_lookup(
self._embedding, update_ids),
dims=self._mlp_dims,
batch_norm=True,
scope=self._scope + '/MLP',
train=False,
reuse=True,
l2_reg=self._l2_reg,
relu_out=True)
self._update_node = tf.scatter_update(
self._embedding, update_ids,
update_embedding.get_outputs()[0])
self._clear_flag = tf.scatter_update(
self._flag, update_ids, tf.zeros_like(update_ids,
dtype=tf.bool))
def _build_item_extractions(self, train=True):
if train:
self._add_module(
'p_item_lf',
LatentFactor(
init='normal',
l2_reg=self._l2_reg,
ids=self._get_input('p_item_id'),
shape=[self._max_item, self._dim_embed - self._dim_ve],
scope='item',
reuse=False))
self._add_module(
'p_item_vf',
MultiLayerFC(in_tensor=self._get_input('p_item_vfeature'),
dims=[self._dim_ve],
scope='item_MLP',
reuse=False))
self._add_module(
'p_item_bias',
LatentFactor(l2_reg=self._l2_reg,
init='zero',
ids=self._get_input('p_item_id'),
shape=[self._max_item, 1],
scope='item_bias',
reuse=False))
self._add_module(
'n_item_lf',
LatentFactor(
init='normal',
l2_reg=self._l2_reg,
ids=self._get_input('n_item_id'),
shape=[self._max_item, self._dim_embed - self._dim_ve],
scope='item',
reuse=True))
self._add_module(
'n_item_vf',
MultiLayerFC(in_tensor=self._get_input('n_item_vfeature'),
dims=[self._dim_ve],
scope='item_MLP',
reuse=True))
self._add_module(
'n_item_bias',
LatentFactor(l2_reg=self._l2_reg,
init='zero',
ids=self._get_input('n_item_id'),
shape=[self._max_item, 1],
scope='item_bias',
reuse=True))
else:
self._add_module('item_lf',
LatentFactor(init='normal',
l2_reg=self._l2_reg,
ids=self._get_input('item_id',
train=train),
shape=[
self._max_item,
self._dim_embed - self._dim_ve
],
scope='item',
reuse=True),
train=False)
self._add_module('item_vf',
MultiLayerFC(in_tensor=self._get_input(
'item_vfeature', train=train),
dims=[self._dim_ve],
scope='item_MLP',
reuse=True),
train=False)
self._add_module('item_bias',
LatentFactor(l2_reg=self._l2_reg,
init='zero',
ids=self._get_input('item_id',
train=train),
shape=[self._max_item, 1],
scope='item_bias',
reuse=True),
train=False)
