def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
linear_tensors = []
embedding_tensors = []
for column in self.columns:
sparse_tensors = column.get_sparse_tensors(transformation_cache,
None)
linear_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(
column, "weights"),
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
linear_tensors.append(linear_tensor)
embedding_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(
column, "embeddings"),
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="mean")
embedding_tensors.append(embedding_tensor)
linear_logits_no_bias = tf.math.reduce_sum(
tf.math.add_n(linear_tensors), axis=1, keepdims=True)
linear_logits = tf.nn.bias_add(linear_logits_no_bias, self.bias)
embedding_tensor = tf.stack(embedding_tensors, axis=1)
embedding_sum_square = tf.math.square(
tf.math.reduce_sum(embedding_tensor, axis=1))
embedding_square_sum = tf.math.reduce_sum(
tf.math.square(embedding_tensor), axis=1)
embedding_logits = tf.math.reduce_sum(
embedding_sum_square - embedding_square_sum, axis=1) * 0.5
logits = linear_logits + embedding_logits
predict = tf.keras.activations.sigmoid(logits)
return predict
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
user_sparse_tensors = self.user_column.get_sparse_tensors(transformation_cache, None)
user_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(self.user_column, "embeddings"),
sparse_ids=user_sparse_tensors.id_tensor,
sparse_weights=user_sparse_tensors.weight_tensor)
self.add_loss(self.regularizer_embedding(user_embedding))
user_history_embeddings = []
for user_history_column in self.user_history_columns:
user_history_sparse_tensors = user_history_column.get_sparse_tensors(transformation_cache, None)
user_history_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(user_history_column, "embeddings"),
sparse_ids=user_history_sparse_tensors.id_tensor,
sparse_weights=user_history_sparse_tensors.weight_tensor,
combiner="sqrtn")
user_history_embeddings.append(user_history_embedding)
self.add_loss(self.regularizer_embedding(user_history_embedding))
user_full_embedding = user_embedding + tf.math.add_n(user_history_embeddings)
item_sparse_tensors = self.item_column.get_sparse_tensors(transformation_cache, None)
item_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(self.item_column, "embeddings"),
sparse_ids=item_sparse_tensors.id_tensor,
sparse_weights=item_sparse_tensors.weight_tensor)
self.add_loss(self.regularizer_embedding(item_embedding))
score_no_bias = tf.math.reduce_sum(tf.math.multiply(user_full_embedding, item_embedding), axis=1)
bias = self.average_score + self.user_bias + self.item_bias
self.add_loss(self.regularizer_bias(self.user_bias))
self.add_loss(self.regularizer_bias(self.item_bias))
score = tf.nn.bias_add(score_no_bias, bias)
return score
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
output_tensors = []
for column in self.columns:
column_weight = self.state_manager.get_variable(column, "weights")
self.add_loss(self.regularizer(column_weight))
if isinstance(column, CategoricalColumn):
sparse_tensors = column.get_sparse_tensors(
transformation_cache, None)
output_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=column_weight,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
output_tensors.append(output_tensor)
elif isinstance(column, DenseColumn):
dense_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
output_tensor = tf.matmul(dense_tensor, column_weight)
output_tensors.append(output_tensor)
for column in self.cross_columns:
sparse_tensors = column.get_sparse_tensors(transformation_cache,
None)
column_weight = self.state_manager.get_variable(column, "weights")
self.add_loss(self.regularizer(column_weight))
output_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=column_weight,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
output_tensors.append(output_tensor)
logits_no_bias = tf.math.add_n(output_tensors)
logits = tf.nn.bias_add(logits_no_bias, self.bias)
predict = tf.keras.activations.sigmoid(logits)
return predict
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
user_sparse_tensors = self.user_column.get_sparse_tensors(transformation_cache, None)
user_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(self.user_column, "embeddings"),
sparse_ids=user_sparse_tensors.id_tensor,
sparse_weights=user_sparse_tensors.weight_tensor)
self.add_loss(self.regularizer(user_embedding))
item_sparse_tensors = self.item_column.get_sparse_tensors(transformation_cache, None)
item_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(self.item_column, "embeddings"),
sparse_ids=item_sparse_tensors.id_tensor,
sparse_weights=item_sparse_tensors.weight_tensor)
self.add_loss(self.regularizer(item_embedding))
score_no_bias = tf.math.reduce_sum(tf.math.multiply(user_embedding, item_embedding), axis=1, keepdims=True)
user_bias = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.user_bias,
sparse_ids=user_sparse_tensors.id_tensor)
item_bias = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.item_bias,
sparse_ids=item_sparse_tensors.id_tensor)
self.add_loss(self.regularizer(self.user_bias))
self.add_loss(self.regularizer(self.item_bias))
score = tf.nn.bias_add(score_no_bias + user_bias + item_bias, self.average_score)
return score_no_bias + user_bias + item_bias
def call(self, inputs, **kwargs):
transformation_cache = FeatureTransformationCache(inputs)
item_feature_tensors = []
item_id_sparse_tensors = self.item_id_column.get_sparse_tensors(
transformation_cache, None)
item_id_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(
self.item_id_column, "item_id_embedding"),
sparse_ids=item_id_sparse_tensors.id_tensor,
sparse_weights=item_id_sparse_tensors.weight_tensor)
item_feature_tensors.append(item_id_tensor)
for item_feature_column in self.item_feature_columns:
item_feature_sparse_tensors = item_feature_column.get_sparse_tensors(
transformation_cache, None)
item_feature_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(
item_feature_column,
"%s_embedding" % item_feature_column.name),
sparse_ids=item_feature_sparse_tensors.id_tensor,
sparse_weights=item_feature_sparse_tensors.weight_tensor,
combiner="mean")
item_feature_tensors.append(item_feature_tensor)
item_features_tensor = tf.stack(item_feature_tensors, axis=1)
with tf.name_scope("WeightedItemFeature"):
item_weights = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.feature_weights,
sparse_ids=item_id_sparse_tensors.id_tensor)
item_weights_exp = tf.math.exp(item_weights)
item_weights = item_weights_exp / tf.reduce_sum(item_weights_exp)
weighted_item_features_tensor = tf.matmul(item_features_tensor)
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
embedding_tensors = []
for column in self.feature_columns:
embedding_weights = self.state_manager.get_variable(
column, "embedding_weights")
if isinstance(column, DenseColumn):
dense_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
input_tensor = tf.matmul(dense_tensor, embedding_weights)
elif isinstance(column, CategoricalColumn):
sparse_tensors = column.get_sparse_tensors(
transformation_cache, self.state_manager)
input_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=embedding_weights,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="mean")
embedding_tensors.append(input_tensor)
product_tensor = self.product_layer(embedding_tensors)
net = tf.add_n(embedding_tensors) + product_tensor
net = tf.nn.bias_add(net, self.product_bias)
net = tf.keras.activations.relu(net)
for layer_index in range(len(self.dense_layers)):
net = self.dense_layers[layer_index](net)
if self.dropout_layers:
net = self.dropout_layers[layer_index](net, training=True)
logits = self.score_layer(net)
return logits
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
input_tensors = []
for column in self.feature_columns:
dense_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
input_tensors.append(dense_tensor)
tensor = self.stack_layer(input_tensors)
tensor = self.residual_layer(tensor)
logits = self.score_layer(tensor)
return logits
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
linear_tensors = []
for column in self.columns:
sparse_tensors = column.get_sparse_tensors(transformation_cache,
None)
linear_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=self.state_manager.get_variable(
column, "weights"),
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
linear_tensors.append(linear_tensor)
cross_tensors = []
for i in range(self.columns_count - 1):
column_i = self.columns[i]
column_i_embeddings = self.state_manager.get_variable(
column_i, "embeddings")
column_i_sparse_tensors = column_i.get_sparse_tensors(
transformation_cache, None)
for j in range(i + 1, self.columns_count):
column_j = self.columns[j]
column_j_embeddings = self.state_manager.get_variable(
column_j, "embeddings")
column_j_sparse_tensors = column_j.get_sparse_tensors(
transformation_cache, None)
column_ixj_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=tf.squeeze(tf.slice(column_i_embeddings,
begin=[j - 1, 0, 0],
size=[1, -1, -1]),
axis=0),
sparse_ids=column_i_sparse_tensors.id_tensor,
sparse_weights=column_i_sparse_tensors.weight_tensor)
column_jxi_embedding = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=tf.squeeze(tf.slice(column_j_embeddings,
begin=[i, 0, 0],
size=[1, -1, -1]),
axis=0),
sparse_ids=column_j_sparse_tensors.id_tensor,
sparse_weights=column_j_sparse_tensors.weight_tensor)
cross_tensor = tf.math.multiply(column_ixj_embedding,
column_jxi_embedding)
cross_tensor = tf.math.reduce_sum(cross_tensor,
axis=1,
keepdims=True)
cross_tensors.append(cross_tensor)
logits_no_bias = tf.math.add_n(linear_tensors) + tf.math.add_n(
cross_tensors)
logits = tf.nn.bias_add(logits_no_bias, self.bias)
return logits
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
softmax_output_tensors = []
sigmoid_output_tensors = []
for column in self.columns:
softmax_weights = self.state_manager.get_variable(
column, "softmax_weights")
self.add_loss(self.regularizer(softmax_weights))
sigmoid_weights = self.state_manager.get_variable(
column, "sigmoid_weights")
self.add_loss(self.regularizer(sigmoid_weights))
if isinstance(column, DenseColumn):
dense_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
softmax_output_tensor = tf.matmul(dense_tensor,
softmax_weights)
sigmoid_output_tensor = tf.matmul(dense_tensor,
sigmoid_weights)
elif isinstance(column, CategoricalColumn):
sparse_tensors = column.get_sparse_tensors(
transformation_cache, None)
softmax_output_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=softmax_weights,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
sigmoid_output_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=sigmoid_weights,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
else:
raise
softmax_output_tensors.append(softmax_output_tensor)
sigmoid_output_tensors.append(sigmoid_output_tensor)
softmax_tensor = tf.nn.bias_add(tf.math.add_n(softmax_output_tensors),
self.softmax_bias)
sigmoid_tensor = tf.nn.bias_add(tf.math.add_n(sigmoid_output_tensors),
self.sigmoid_bias)
softmax_tensor = tf.math.exp(softmax_tensor)
softmax_tensor = softmax_tensor / tf.math.reduce_sum(
softmax_tensor, axis=1, keepdims=True)
sigmoid_tensor = 1 / (1 + tf.math.exp(sigmoid_tensor))
logits = tf.math.reduce_sum(tf.math.multiply(softmax_tensor,
sigmoid_tensor),
axis=1,
keepdims=True)
return logits
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
feature_column_tensors = []
for feature_column in self.feature_columns:
feature_tensor = feature_column.get_dense_tensor(transformation_cache, self.state_manager)
feature_column_tensors.append(feature_tensor)
output_tensor = tf.concat(feature_column_tensors, axis=1)
for layer_index, dense_layer in enumerate(self.dense_layers):
output_tensor = dense_layer(output_tensor)
if self.dropout:
output_tensor = self.dropout_layers[layer_index](output_tensor, training)
if self.batch_norm:
output_tensor = self.batch_norm_layers[layer_index](output_tensor, training)
logits = self.logits_layer(output_tensor)
predict = tf.keras.activations.sigmoid(logits)
return predict
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
user_tensors = []
for user_column in self.user_columns:
user_tensor = user_column.get_dense_tensor(transformation_cache, self.state_manager)
user_tensors.append(user_tensor)
item_tensors = []
for item_column in self.item_columns:
item_tensor = item_column.get_dense_tensor(transformation_cache, self.state_manager)
item_tensors.append(item_tensor)
user_input_tensor = tf.concat(user_tensors, axis=1)
item_input_tensor = tf.concat(item_tensors, axis=1)
gmf_tensor = self.gmf_layer([user_input_tensor, item_input_tensor])
mlp_tensor = tf.concat([user_input_tensor, item_input_tensor], axis=1)
for layer_index in range(len(self.denser_layers)):
mlp_tensor = self.denser_layers[layer_index](mlp_tensor)
if self.dropout_layers:
mlp_tensor = self.dropout_layers[layer_index](mlp_tensor, training=True)
output_tensor = tf.concat([gmf_tensor, mlp_tensor], axis=1)
logits = self.score_layer(output_tensor)
return logits
def call(self, inputs, training=None, mask=None):
transformation_cache = FeatureTransformationCache(inputs)
linear_tensors = []
for column in self.linear_columns:
column_weights = self.state_manager.get_variable(
column, "linear_weights")
if isinstance(column, CategoricalColumn):
sparse_tensors = column.get_sparse_tensors(
transformation_cache, self.state_manager)
linear_tensor = tf.nn.safe_embedding_lookup_sparse(
embedding_weights=column_weights,
sparse_ids=sparse_tensors.id_tensor,
sparse_weights=sparse_tensors.weight_tensor,
combiner="sum")
elif isinstance(column, DenseColumn):
dense_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
linear_tensor = tf.matmul(dense_tensor, column_weights)
linear_tensors.append(linear_tensor)
linear_net = tf.concat(linear_tensors, axis=1)
dnn_tensors = []
for column in self.dnn_columns:
column_weights = self.state_manager.get_variable(
column, "dnn_weights")
dnn_tensor = column.get_dense_tensor(transformation_cache,
self.state_manager)
dnn_tensor = tf.matmul(dnn_tensor, column_weights)
dnn_tensors.append(dnn_tensor)
dnn_net = tf.concat(dnn_tensors, axis=1)
for layer_index in range(len(self.dense_layers)):
dnn_net = self.dense_layers[layer_index](dnn_net)
if self.dropout_layers:
dnn_net = self.dropout_layers[layer_index](dnn_net,
training=True)
net = tf.concat([linear_net, dnn_net], axis=1)
logits = self.logits_layer(net)
return logits