def xDeepFM_MTL(
feature_dim_dict,
embedding_size=8,
hidden_size=(256, 256),
cin_layer_size=(
256,
256,
),
cin_split_half=True,
task_net_size=(128, ),
l2_reg_linear=0.00001,
l2_reg_embedding=0.00001,
seed=1024,
):
check_feature_config_dict(feature_dim_dict)
if len(task_net_size) < 1:
raise ValueError('task_net_size must be at least one layer')
print("[xdeepfm] feature_dim_dict: {}".format(feature_dim_dict))
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, l2_reg_linear,
0.0001, seed)
print("[xdeepfm] deep_emb_list:", deep_emb_list)
print("[xdeepfm] linear_logit:", linear_logit)
print("[xdeepfm] inputs_list:", inputs_list)
# video_input = tf.keras.layers.Input((128,))
# inputs_list.append(video_input)
fm_input = concat_fun(deep_emb_list, axis=1)
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, 'relu', cin_split_half, seed)(fm_input)
exFM_logit = tf.keras.layers.Dense(
1,
activation=None,
)(exFM_out)
deep_input = tf.keras.layers.Flatten()(fm_input)
deep_out = MLP(hidden_size)(deep_input)
finish_out = MLP(task_net_size)(deep_out)
finish_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(finish_out)
like_out = MLP(task_net_size)(deep_out)
like_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(like_out)
finish_logit = tf.keras.layers.add(
[linear_logit, finish_logit, exFM_logit])
like_logit = tf.keras.layers.add([linear_logit, like_logit, exFM_logit])
output_finish = PredictionLayer('sigmoid', name='finish')(finish_logit)
output_like = PredictionLayer('sigmoid', name='like')(like_logit)
model = tf.keras.models.Model(inputs=inputs_list,
outputs=[output_finish, output_like])
return model
def myAutoInt(
feature_dim_dict,
embedding_size=8,
att_layer_num=3,
att_embedding_size=8,
att_head_num=4,
att_res=True,
hidden_size=(256, 256),
activation='relu',
l2_reg_deep=0,
l2_reg_embedding=1e-5,
use_bn=False,
keep_prob=1.0,
init_std=0.0001,
seed=1024,
final_activation='sigmoid',
):
if len(hidden_size) <= 0 and att_layer_num <= 0:
raise ValueError("Either hidden_layer or att_layer_num must > 0")
check_feature_config_dict(feature_dim_dict)
deep_emb_list, _, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, 0, init_std, seed,
False)
att_input = concat_fun(deep_emb_list, axis=1)
for _ in range(att_layer_num):
att_input = InteractingLayer(att_embedding_size, att_head_num,
att_res)(att_input)
att_output = tf.keras.layers.Flatten()(att_input)
deep_input = tf.keras.layers.Flatten()(concat_fun(deep_emb_list))
deep_out = MLP(hidden_size, activation, l2_reg_deep, keep_prob, use_bn,
seed)(deep_input)
finish_out = tf.keras.layers.Concatenate()([att_output, deep_out])
finish_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(finish_out)
like_out = tf.keras.layers.Concatenate()([att_output, deep_out])
like_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(like_out)
output_finish = PredictionLayer(final_activation,
name='finish')(finish_logit)
output_like = PredictionLayer(final_activation, name='like')(like_logit)
model = tf.keras.models.Model(inputs=inputs_list,
outputs=[output_finish, output_like])
return model
def CapsuleNet(feature_dim_dict,
seq_feature_list,
embedding_size=8,
hist_len_max=50,
use_bn=False,
dnn_hidden_units=(200, 80),
dnn_activation='sigmoid',
num_capsule=8,
dim_capsule=2,
routing_iterations=3,
att_hidden_size=(64, 16),
att_activation="dice",
att_weight_normalization=True,
att_embedding_size=1,
att_head_num=8,
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
dnn_dropout=0,
init_std=0.0001,
alpha=1e-6,
seed=1024,
task='binary'):
check_feature_config_dict(feature_dim_dict)
sparse_input, dense_input, user_behavior_input, user_behavior_length = get_input(
feature_dim_dict, seq_feature_list, hist_len_max)
sparse_embedding_dict = {
feat.name:
Embedding(feat.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name,
mask_zero=(feat.name in seq_feature_list))
for i, feat in enumerate(feature_dim_dict["sparse"])
}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict["sparse"],
return_feat_list=seq_feature_list)
keys_emb_list = get_embedding_vec_list(sparse_embedding_dict,
user_behavior_input,
feature_dim_dict['sparse'],
return_feat_list=seq_feature_list)
deep_input_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict['sparse'])
query_emb = concat_fun(query_emb_list)
keys_emb = concat_fun(keys_emb_list)
scores = AttentionSequencePoolingLayer(
att_hidden_units=att_hidden_size,
att_activation=att_activation,
weight_normalization=att_weight_normalization,
return_score=True)([query_emb, keys_emb, user_behavior_length])
Self_Attention = Transformer(att_embedding_size,
att_head_num,
dropout_rate=0,
use_layer_norm=True,
use_positional_encoding=True,
seed=seed,
supports_masking=False,
blinding=True)
keys_emb = Self_Attention(
[keys_emb, keys_emb, user_behavior_length, user_behavior_length])
cap = Capsule(num_capsule=num_capsule,
dim_capsule=dim_capsule,
routings=routing_iterations,
share_weights=True,
supports_masking=True)
hist_cap = cap(keys_emb, scores=scores)
disp_loss = get_disp_loss(hist_cap)
hist_cap = Reshape([1, num_capsule * dim_capsule])(NoMask()(hist_cap))
deep_input_emb = concat_fun(deep_input_emb_list)
deep_input_emb = Concatenate()([deep_input_emb, hist_cap])
deep_input_emb = tf.keras.layers.Flatten()(NoMask()(deep_input_emb))
if len(dense_input) > 0:
deep_input_emb = Concatenate()([deep_input_emb] +
list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
use_bn, seed)(deep_input_emb)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model_input_list = get_inputs_list(
[sparse_input, dense_input, user_behavior_input])
model_input_list += [user_behavior_length]
model = tf.keras.models.Model(inputs=model_input_list, outputs=output)
model.add_loss(alpha * disp_loss)
tf.keras.backend.get_session().run(tf.global_variables_initializer())
return model
def DSIN(
feature_dim_dict,
sess_feature_list,
embedding_size=8,
sess_max_count=5,
sess_len_max=10,
att_embedding_size=1,
att_head_num=8,
dnn_hidden_units=(200, 80),
dnn_activation='sigmoid',
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
task='binary',
dnn_dropout=0,
init_std=0.0001,
seed=1024,
encoding='bias',
):
check_feature_config_dict(feature_dim_dict)
print(
'sess_count',
sess_max_count,
'encoding',
encoding,
)
sparse_input, dense_input, user_behavior_input_dict, _, user_sess_length = get_input(
feature_dim_dict, sess_feature_list, sess_max_count, sess_len_max)
sparse_embedding_dict = {
feat.name:
Embedding(feat.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name,
mask_zero=(feat.name in sess_feature_list))
for i, feat in enumerate(feature_dim_dict["sparse"])
}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict["sparse"],
sess_feature_list,
sess_feature_list)
query_emb = concat_fun(query_emb_list)
deep_input_emb_list = get_embedding_vec_list(
sparse_embedding_dict,
sparse_input,
feature_dim_dict["sparse"],
mask_feat_list=sess_feature_list)
deep_input_emb = concat_fun(deep_input_emb_list)
deep_input_emb = Flatten()(NoMask()(deep_input_emb))
be_flag = True if encoding == 'bias' else False
tr_input = sess_interest_division(sparse_embedding_dict,
user_behavior_input_dict,
feature_dim_dict['sparse'],
sess_feature_list,
sess_max_count,
bias_encoding=be_flag)
Self_Attention = Transformer(att_embedding_size,
att_head_num,
dropout_rate=0,
use_layer_norm=False,
use_positional_encoding=(not be_flag),
seed=seed,
supports_masking=True,
blinding=True)
sess_fea = sess_interest_extractor(tr_input, sess_max_count,
Self_Attention)
interest_attention_layer = AttentionSequencePoolingLayer(
att_hidden_units=(64, 16),
weight_normalization=True,
supports_masking=False)([query_emb, sess_fea, user_sess_length])
lstm_outputs = BiLSTM(
len(sess_feature_list) * embedding_size,
layers=2,
res_layers=0,
dropout_rate=0.2,
)(sess_fea)
lstm_attention_layer = AttentionSequencePoolingLayer(
att_hidden_units=(64, 16),
weight_normalization=True)([query_emb, lstm_outputs, user_sess_length])
deep_input_emb = Concatenate()([
deep_input_emb,
Flatten()(interest_attention_layer),
Flatten()(lstm_attention_layer)
])
if len(dense_input) > 0:
deep_input_emb = Concatenate()([deep_input_emb] +
list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
False, seed)(deep_input_emb)
output = Dense(1, use_bias=False, activation=None)(output)
output = PredictionLayer(task)(output)
sess_input_list = []
#sess_input_length_list = []
for i in range(sess_max_count):
sess_name = "sess_" + str(i)
sess_input_list.extend(
get_inputs_list([user_behavior_input_dict[sess_name]]))
#sess_input_length_list.append(user_behavior_length_dict[sess_name])
model_input_list = get_inputs_list(
[sparse_input, dense_input]) + sess_input_list + [user_sess_length]
model = Model(inputs=model_input_list, outputs=output)
return model
def MTL_with_Title(
feature_dim_dict,
embedding_size=8,
hidden_size=(256, 256),
cin_layer_size=(
256,
256,
),
cin_split_half=True,
task_net_size=(128, ),
l2_reg_linear=0.00001,
l2_reg_embedding=0.00001,
seed=1024,
):
check_feature_config_dict(feature_dim_dict)
if len(task_net_size) < 1:
raise ValueError('task_net_size must be at least one layer')
# xDeepFM Model
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, l2_reg_linear,
0.0001, seed)
fm_input = concat_fun(deep_emb_list, axis=1)
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, 'relu', cin_split_half, seed)(fm_input)
exFM_logit = tf.keras.layers.Dense(
1,
activation=None,
)(exFM_out)
deep_input = tf.keras.layers.Flatten()(fm_input)
deep_out = MLP(hidden_size)(deep_input)
finish_out = MLP(task_net_size)(deep_out)
finish_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(finish_out)
like_out = MLP(task_net_size)(deep_out)
like_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(like_out)
# Add Title Features
title_input = Input(shape=(35, ), dtype='int32', name='title_input')
title_embedding = Embedding(output_dim=32,
input_dim=134545,
input_length=35)(title_input)
lstm_out = LSTM(units=32, return_sequences=True)(title_embedding)
avg_out = GlobalAveragePooling1D()(lstm_out)
dense1 = Dense(32, activation='relu')(avg_out)
dense2 = Dense(1, activation='relu')(dense1)
#
finish_logit = tf.keras.layers.add(
[linear_logit, finish_logit, exFM_logit, dense2])
like_logit = tf.keras.layers.add(
[linear_logit, like_logit, exFM_logit, dense2])
output_finish = PredictionLayer('sigmoid', name='finish')(finish_logit)
output_like = PredictionLayer('sigmoid', name='like')(like_logit)
print(str(inputs_list))
inputs_list.append(title_input)
model = tf.keras.models.Model(inputs=inputs_list,
outputs=[output_finish, output_like])
return model
def DeepFM(feature_dim_dict,
attention_feature_name=None,
embedding_size=8,
use_fm=True,
dnn_hidden_units=(128, 128),
l2_reg_linear=0.00001,
l2_reg_embedding=0.00001,
l2_reg_dnn=0,
init_std=0.0001,
seed=1024,
dnn_dropout=0,
dnn_activation='relu',
dnn_use_bn=False,
task='binary'):
"""Instantiates the DeepFM Network architecture.
:param feature_dim_dict: dict,to indicate sparse field and dense field like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':['field_4','field_5']}
:param embedding_size: positive integer,sparse feature embedding_size
:param use_fm: bool,use FM part or not
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of DNN
:param l2_reg_linear: float. L2 regularizer strength applied to linear part
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param dnn_activation: Activation function to use in DNN
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in DNN
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
deep_emb_list, linear_emb_list, dense_input_dict, inputs_list = \
preprocess_input_embedding(feature_dim_dict,
embedding_size,
l2_reg_embedding,
l2_reg_linear, init_std,
seed,
create_linear_weight=True,
use_var_attention=(
True if attention_feature_name else False),
attention_feature_name=attention_feature_name)
linear_logit = get_linear_logit(linear_emb_list, dense_input_dict,
l2_reg_linear)
fm_input = concat_fun(deep_emb_list, axis=1)
deep_input = tf.keras.layers.Flatten()(fm_input)
fm_out = FM()(fm_input)
deep_out = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
dnn_use_bn, seed)(deep_input)
deep_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(deep_out)
if len(dnn_hidden_units) == 0 and use_fm == False: # only linear
final_logit = linear_logit
elif len(dnn_hidden_units) == 0 and use_fm == True: # linear + FM
final_logit = tf.keras.layers.add([linear_logit, fm_out])
elif len(dnn_hidden_units) > 0 and use_fm == False: # linear + Deep
final_logit = tf.keras.layers.add([linear_logit, deep_logit])
elif len(dnn_hidden_units) > 0 and use_fm == True: # linear + FM + Deep
final_logit = tf.keras.layers.add([linear_logit, fm_out, deep_logit])
else:
raise NotImplementedError
output = PredictionLayer(task)(final_logit)
model = tf.keras.models.Model(inputs=inputs_list, outputs=output)
return model
def xDeepFM_MTL(
feature_dim_dict,
embedding_size=8,
hidden_size=(256, 256),
cin_layer_size=(
256,
256,
),
cin_split_half=True,
task_net_size=(128, ),
l2_reg_linear=0.000001,
l2_reg_embedding=0.000001,
seed=1024,
):
check_feature_config_dict(feature_dim_dict) # 未知
if len(task_net_size) < 1:
raise ValueError('task_net_size must be at least one layer')
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, l2_reg_linear,
0.0001, seed)
# video_input = tf.keras.layers.Input((128,))
# inputs_list.append(video_input)
fm_input = concat_fun(deep_emb_list, axis=1) # 模型输入
'''
构建CIN，默认CIN的size为[256,256]，激活函数为relu，输入为
(batch_size,field_size,embedding_size)，输出为(batch_size,feature_num)。
如果split_half为True，那么隐藏层的feature map只有一半的会连接到输出单元。
'''
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, 'relu', cin_split_half, seed)(fm_input)
exFM_logit = tf.keras.layers.Dense(
1,
activation=None,
)(exFM_out) # 全连接输出到Output_unit
'''
Flatten将输入除了batch的维度，其他维度拉直，得到的输出为(batch_size, sum_size)
将embedding特征直接输入MLP
'''
deep_input = tf.keras.layers.Flatten()(fm_input)
deep_out = MLP(hidden_size)(deep_input)
'''
将deep_out过一个MLP，并全连接到finish的logits输出，同样的操作应用于like的logits输出
'''
finish_out = MLP(task_net_size)(deep_out)
finish_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(finish_out)
like_out = MLP(task_net_size)(deep_out)
like_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(like_out)
'''
最终的finish的logit由linear_logit,finish_logit\like_logit和exFM_logit三者叠加。
'''
finish_logit = tf.keras.layers.add(
[linear_logit, finish_logit, exFM_logit])
like_logit = tf.keras.layers.add([linear_logit, like_logit, exFM_logit])
'''
将logit通过sigmoid转化为概率，通过输入和输出构建model
'''
output_finish = PredictionLayer('sigmoid', name='finish')(finish_logit)
output_like = PredictionLayer('sigmoid', name='like')(like_logit)
model = tf.keras.models.Model(inputs=inputs_list,
outputs=[output_finish, output_like])
return model
def xDeepFM_MTL(feature_dim_dict, embedding_size=8, hidden_size=(256, 256), cin_layer_size=(256, 256,),
cin_split_half=True,
task_net_size=(128,), l2_reg_linear=0.00001, l2_reg_embedding=0.00001,
seed=1024, ):
"""
:param feature_dim_dict: 特征词典，包括特征名和特征列表
:param embedding_size:
:param hidden_size:
:param cin_layer_size:
:param cin_split_half:
:param task_net_size: 网络层数
:param l2_reg_linear:
:param l2_reg_embedding:
:param seed:
:return:
"""
# 判断sparse 和dense feature结构是否正确
check_feature_config_dict(feature_dim_dict)
if len(task_net_size) < 1:
raise ValueError('task_net_size must be at least one layer')
# Todo, add text sequence embedding
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, l2_reg_linear, 0.0001, seed)
# video_input = tf.keras.layers.Input((128,))
# inputs_list.append(video_input)
# TODO, add other feature
if 'txt' in feature_dim_dict:
# txt_input = OrderedDict()
for i, feat in enumerate(feature_dim_dict["txt"]):
txt_input = tf.keras.layers.Input(
shape=(feat.dimension,), name='txt_' + str(i) + '-' + feat.name)
inputs_list.append(txt_input)
fm_input = concat_fun(deep_emb_list, axis=1)
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, 'relu',
cin_split_half, seed)(fm_input)
exFM_logit = tf.keras.layers.Dense(1, activation=None, )(exFM_out)
deep_input = tf.keras.layers.Flatten()(fm_input)
deep_out = MLP(hidden_size)(deep_input)
finish_out = MLP(task_net_size)(deep_out)
finish_logit = tf.keras.layers.Dense(
1, use_bias=False, activation=None)(finish_out)
like_out = MLP(task_net_size)(deep_out)
like_logit = tf.keras.layers.Dense(
1, use_bias=False, activation=None)(like_out)
finish_logit = tf.keras.layers.add(
[linear_logit, finish_logit, exFM_logit])
like_logit = tf.keras.layers.add(
[linear_logit, like_logit, exFM_logit])
output_finish = PredictionLayer('sigmoid', name='finish')(finish_logit)
output_like = PredictionLayer('sigmoid', name='like')(like_logit)
model = tf.keras.models.Model(inputs=inputs_list, outputs=[
output_finish, output_like])
return model
def DIN(feature_dim_dict,
seq_feature_list,
embedding_size=8,
hist_len_max=16,
dnn_use_bn=False,
dnn_hidden_units=(200, 80),
dnn_activation='relu',
att_hidden_size=(80, 40),
att_activation="dice",
att_weight_normalization=False,
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
dnn_dropout=0,
init_std=0.0001,
seed=1024,
task='binary'):
"""Instantiates the Deep Interest Network architecture.
:param feature_dim_dict: dict,to indicate sparse field (**now only support sparse feature**)like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':[]}
:param seq_feature_list: list,to indicate sequence sparse field (**now only support sparse feature**),must be a subset of ``feature_dim_dict["sparse"]``
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param dnn_activation: Activation function to use in deep net
:param att_hidden_size: list,list of positive integer , the layer number and units in each layer of attention net
:param att_activation: Activation function to use in attention net
:param att_weight_normalization: bool.Whether normalize the attention score of local activation unit.
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
sparse_input, dense_input, user_behavior_input = get_input(
feature_dim_dict, seq_feature_list, hist_len_max)
sparse_embedding_dict = {
feat.name:
Embedding(feat.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name,
mask_zero=(feat.name in seq_feature_list))
for i, feat in enumerate(feature_dim_dict["sparse"])
}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict['sparse'],
seq_feature_list, seq_feature_list)
keys_emb_list = get_embedding_vec_list(sparse_embedding_dict,
user_behavior_input,
feature_dim_dict['sparse'],
seq_feature_list, seq_feature_list)
deep_input_emb_list = get_embedding_vec_list(
sparse_embedding_dict,
sparse_input,
feature_dim_dict['sparse'],
mask_feat_list=seq_feature_list)
keys_emb = concat_fun(keys_emb_list)
deep_input_emb = concat_fun(deep_input_emb_list)
query_emb = concat_fun(query_emb_list)
hist = AttentionSequencePoolingLayer(
att_hidden_size,
att_activation,
weight_normalization=att_weight_normalization,
supports_masking=True)([query_emb, keys_emb])
deep_input_emb = Concatenate()([NoMask()(deep_input_emb), hist])
deep_input_emb = Flatten()(deep_input_emb)
if len(dense_input) > 0:
deep_input_emb = Concatenate()([deep_input_emb] +
list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
dnn_use_bn, seed)(deep_input_emb)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model_input_list = get_inputs_list(
[sparse_input, dense_input, user_behavior_input])
model = Model(inputs=model_input_list, outputs=output)
return model
def DSIN(
feature_dim_dict,
sess_feature_list,
embedding_size=8,
sess_max_count=5,
sess_len_max=10,
bias_encoding=False,
att_embedding_size=1,
att_head_num=8,
dnn_hidden_units=(200, 80),
dnn_activation='sigmoid',
dnn_dropout=0,
dnn_use_bn=False,
l2_reg_dnn=0,
l2_reg_embedding=1e-6,
init_std=0.0001,
seed=1024,
task='binary',
):
"""Instantiates the Deep Session Interest Network architecture.
:param feature_dim_dict: dict,to indicate sparse field (**now only support sparse feature**)like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':[]}
:param sess_feature_list: list,to indicate session feature sparse field (**now only support sparse feature**),must be a subset of ``feature_dim_dict["sparse"]``
:param embedding_size: positive integer,sparse feature embedding_size.
:param sess_max_count: positive int, to indicate the max number of sessions
:param sess_len_max: positive int, to indicate the max length of each session
:param bias_encoding: bool. Whether use bias encoding or postional encoding
:param att_embedding_size: positive int, the embedding size of each attention head
:param att_head_num: positive int, the number of attention head
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of deep net
:param dnn_activation: Activation function to use in deep net
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param dnn_use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
if (att_embedding_size * att_head_num !=
len(sess_feature_list) * embedding_size):
raise ValueError(
"len(session_feature_lsit) * embedding_size must equal to att_embedding_size * att_head_num ,got %d * %d != %d *%d"
% (len(sess_feature_list), embedding_size, att_embedding_size,
att_head_num))
sparse_input, dense_input, user_behavior_input_dict, _, user_sess_length = get_input(
feature_dim_dict, sess_feature_list, sess_max_count, sess_len_max)
sparse_embedding_dict = {
feat.name:
Embedding(feat.dimension,
embedding_size,
embeddings_initializer=RandomNormal(mean=0.0,
stddev=init_std,
seed=seed),
embeddings_regularizer=l2(l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name,
mask_zero=(feat.name in sess_feature_list))
for i, feat in enumerate(feature_dim_dict["sparse"])
}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict,
sparse_input,
feature_dim_dict["sparse"],
sess_feature_list,
sess_feature_list)
query_emb = concat_fun(query_emb_list)
deep_input_emb_list = get_embedding_vec_list(
sparse_embedding_dict,
sparse_input,
feature_dim_dict["sparse"],
mask_feat_list=sess_feature_list)
deep_input_emb = concat_fun(deep_input_emb_list)
deep_input_emb = Flatten()(NoMask()(deep_input_emb))
tr_input = sess_interest_division(sparse_embedding_dict,
user_behavior_input_dict,
feature_dim_dict['sparse'],
sess_feature_list,
sess_max_count,
bias_encoding=bias_encoding)
Self_Attention = Transformer(att_embedding_size,
att_head_num,
dropout_rate=0,
use_layer_norm=False,
use_positional_encoding=(not bias_encoding),
seed=seed,
supports_masking=True,
blinding=True)
sess_fea = sess_interest_extractor(tr_input, sess_max_count,
Self_Attention)
interest_attention_layer = AttentionSequencePoolingLayer(
att_hidden_units=(64, 16),
weight_normalization=True,
supports_masking=False)([query_emb, sess_fea, user_sess_length])
lstm_outputs = BiLSTM(
len(sess_feature_list) * embedding_size,
layers=2,
res_layers=0,
dropout_rate=0.2,
)(sess_fea)
lstm_attention_layer = AttentionSequencePoolingLayer(
att_hidden_units=(64, 16),
weight_normalization=True)([query_emb, lstm_outputs, user_sess_length])
deep_input_emb = Concatenate()([
deep_input_emb,
Flatten()(interest_attention_layer),
Flatten()(lstm_attention_layer)
])
if len(dense_input) > 0:
deep_input_emb = Concatenate()([deep_input_emb] +
list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn, dnn_dropout,
dnn_use_bn, seed)(deep_input_emb)
output = Dense(1, use_bias=False, activation=None)(output)
output = PredictionLayer(task)(output)
sess_input_list = []
# sess_input_length_list = []
for i in range(sess_max_count):
sess_name = "sess_" + str(i)
sess_input_list.extend(
get_inputs_list([user_behavior_input_dict[sess_name]]))
# sess_input_length_list.append(user_behavior_length_dict[sess_name])
model_input_list = get_inputs_list(
[sparse_input, dense_input]) + sess_input_list + [user_sess_length]
model = Model(inputs=model_input_list, outputs=output)
return model
def DIEN(feature_dim_dict, seq_feature_list, embedding_size=8, hist_len_max=16,
gru_type="GRU", use_negsampling=False, alpha=1.0, use_bn=False, dnn_hidden_units=(200, 80),
dnn_activation='relu',
att_hidden_units=(64, 16), att_activation="dice", att_weight_normalization=True,
l2_reg_dnn=0, l2_reg_embedding=1e-6, dnn_dropout=0, init_std=0.0001, seed=1024, task='binary'):
"""Instantiates the Deep Interest Evolution Network architecture.
:param feature_dim_dict: dict,to indicate sparse field (**now only support sparse feature**)like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':[]}
:param seq_feature_list: list,to indicate sequence sparse field (**now only support sparse feature**),must be a subset of ``feature_dim_dict["sparse"]``
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param gru_type: str,can be GRU AIGRU AUGRU AGRU
:param use_negsampling: bool, whether or not use negtive sampling
:param alpha: float ,weight of auxiliary_loss
:param use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of DNN
:param dnn_activation: Activation function to use in DNN
:param att_hidden_units: list,list of positive integer , the layer number and units in each layer of attention net
:param att_activation: Activation function to use in attention net
:param att_weight_normalization: bool.Whether normalize the attention score of local activation unit.
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
sparse_input, dense_input, user_behavior_input, user_behavior_length = get_input(
feature_dim_dict, seq_feature_list, hist_len_max)
sparse_embedding_dict = {feat.name: Embedding(feat.dimension, embedding_size,
embeddings_initializer=RandomNormal(
mean=0.0, stddev=init_std, seed=seed),
embeddings_regularizer=l2(
l2_reg_embedding),
name='sparse_emb_' + str(i) + '-' + feat.name) for i, feat in
enumerate(feature_dim_dict["sparse"])}
query_emb_list = get_embedding_vec_list(sparse_embedding_dict, sparse_input, feature_dim_dict["sparse"],
return_feat_list=seq_feature_list)
keys_emb_list = get_embedding_vec_list(sparse_embedding_dict, user_behavior_input, feature_dim_dict['sparse'],
return_feat_list=seq_feature_list)
deep_input_emb_list = get_embedding_vec_list(sparse_embedding_dict, sparse_input, feature_dim_dict['sparse'])
query_emb = concat_fun(query_emb_list)
keys_emb = concat_fun(keys_emb_list)
deep_input_emb = concat_fun(deep_input_emb_list)
if use_negsampling:
neg_user_behavior_input = OrderedDict()
for i, feat in enumerate(seq_feature_list):
neg_user_behavior_input[feat] = Input(shape=(hist_len_max,), name='neg_seq_' + str(i) + '-' + feat)
neg_uiseq_embed_list = get_embedding_vec_list(sparse_embedding_dict, neg_user_behavior_input,
feature_dim_dict["sparse"], seq_feature_list, )
# [sparse_embedding_dict[feat](
# neg_user_behavior_input[feat]) for feat in seq_feature_list]
neg_concat_behavior = concat_fun(neg_uiseq_embed_list)
else:
neg_concat_behavior = None
hist, aux_loss_1 = interest_evolution(keys_emb, query_emb, user_behavior_length, gru_type=gru_type,
use_neg=use_negsampling, neg_concat_behavior=neg_concat_behavior,
embedding_size=embedding_size, att_hidden_size=att_hidden_units,
att_activation=att_activation,
att_weight_normalization=att_weight_normalization, )
deep_input_emb = Concatenate()([deep_input_emb, hist])
deep_input_emb = tf.keras.layers.Flatten()(deep_input_emb)
if len(dense_input) > 0:
deep_input_emb = Concatenate()(
[deep_input_emb] + list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn,
dnn_dropout, use_bn, seed)(deep_input_emb)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model_input_list = get_inputs_list(
[sparse_input, dense_input, user_behavior_input])
if use_negsampling:
model_input_list += list(neg_user_behavior_input.values())
model_input_list += [user_behavior_length]
model = tf.keras.models.Model(inputs=model_input_list, outputs=output)
if use_negsampling:
model.add_loss(alpha * aux_loss_1)
tf.keras.backend.get_session().run(tf.global_variables_initializer())
return model
def BST(feature_dim_dict, seq_feature_list, embedding_size=4, hist_len_max=16, use_bn=False, dnn_hidden_units=(200, 80),
dnn_activation='relu', att_embedding_size=1, att_head_num=8,
l2_reg_dnn=0, l2_reg_embedding=1e-6, dnn_dropout=0, init_std=0.0001, seed=1024, task='binary'):
"""Instantiates the Deep Interest Evolution Network architecture.
:param feature_dim_dict: dict,to indicate sparse field (**now only support sparse feature**)like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':[]}
:param seq_feature_list: list,to indicate sequence sparse field (**now only support sparse feature**),must be a subset of ``feature_dim_dict["sparse"]``
:param embedding_size: positive integer,sparse feature embedding_size.
:param hist_len_max: positive int, to indicate the max length of seq input
:param use_bn: bool. Whether use BatchNormalization before activation or not in deep net
:param dnn_hidden_units: list,list of positive integer or empty list, the layer number and units in each layer of DNN
:param dnn_activation: Activation function to use in DNN
:param l2_reg_dnn: float. L2 regularizer strength applied to DNN
:param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector
:param dnn_dropout: float in [0,1), the probability we will drop out a given DNN coordinate.
:param init_std: float,to use as the initialize std of embedding vector
:param seed: integer ,to use as random seed.
:param task: str, ``"binary"`` for binary logloss or ``"regression"`` for regression loss
:return: A Keras model instance.
"""
check_feature_config_dict(feature_dim_dict)
sparse_input, dense_input, user_behavior_input, user_behavior_length = get_input(
feature_dim_dict, seq_feature_list, hist_len_max)
# sparse_embedding_dict = {feat.name: Embedding(feat.dimension, embedding_size,
# embeddings_initializer=RandomNormal(
# mean=0.0, stddev=init_std, seed=seed),
# embeddings_regularizer=l2(
# l2_reg_embedding),
# name='sparse_emb_' + str(i) + '-' + feat.name) for i, feat in
# enumerate(feature_dim_dict["sparse"])}
# print(sparse_embedding_dict)
sparse_embedding_dict = {feat.name: Embedding(tf.cast(feat.dimension, tf.int32), embedding_size,
embeddings_initializer=RandomNormal(
mean=0.0, stddev=init_std, seed=seed),
embeddings_regularizer=l2(
l2_reg_embedding),
name='sparse_emb_' +
str(i) + '-' + feat.name,
mask_zero=(feat.name in seq_feature_list)) for i, feat in
enumerate(feature_dim_dict["sparse"])}
# deep_emb_list = get_embedding_vec_list(
# deep_sparse_emb_dict, sparse_input_dict, feature_dim_dict['sparse'])
query_emb_list = get_embedding_vec_list(sparse_embedding_dict, sparse_input, feature_dim_dict["sparse"],
return_feat_list=seq_feature_list)
keys_emb_list = get_embedding_vec_list(sparse_embedding_dict, user_behavior_input, feature_dim_dict['sparse'],
return_feat_list=seq_feature_list)
deep_input_emb_list = get_embedding_vec_list(sparse_embedding_dict, sparse_input, feature_dim_dict['sparse'])
query_emb = concat_fun(query_emb_list)
keys_emb = concat_fun(keys_emb_list)
print("prev: {0}".format(keys_emb))
# hist_cap = Capsule(
# num_capsule=8, dim_capsule=2,
# routings=3, share_weights=True)(NoMask()(keys_emb))
# print("now: {0}".format(hist_cap))
# # exit(0)
# # keys_emb = concat_fun(keys_emb_list)
# hist_cap = Reshape([1, 16])(hist_cap)
deep_input_emb = concat_fun(deep_input_emb_list)
print("deep input emb: ", deep_input_emb)
# print("hist_cap: ", hist_cap)
Self_Attention = Transformer(att_embedding_size, att_head_num, dropout_rate=0, use_layer_norm=False,
use_positional_encoding=True, seed=seed, supports_masking=False,
blinding=True)
# print("now: {0}".format(hist))
hists = []
for key_emb in keys_emb_list:
hist = Self_Attention([key_emb, key_emb, user_behavior_length, user_behavior_length])
hists.append(hist)
hist = concat_fun(hists)
# Tensor("concatenate_2/concat:0", shape=(?, 50, 8), dtype=float32)
# <tf.Tensor 'concatenate_3/concat:0' shape=(?, 4, 8) dtype=float32>
deep_input_emb = Concatenate()([deep_input_emb, hist])
# print(deep_input_emb)
deep_input_emb = tf.keras.layers.Flatten()(NoMask()(deep_input_emb))
if len(dense_input) > 0:
deep_input_emb = Concatenate()(
[deep_input_emb] + list(dense_input.values()))
output = DNN(dnn_hidden_units, dnn_activation, l2_reg_dnn,
dnn_dropout, use_bn, seed)(deep_input_emb)
final_logit = Dense(1, use_bias=False)(output)
output = PredictionLayer(task)(final_logit)
model_input_list = get_inputs_list(
[sparse_input, dense_input, user_behavior_input])
model_input_list += [user_behavior_length]
model = tf.keras.models.Model(inputs=model_input_list, outputs=output)
tf.keras.backend.get_session().run(tf.global_variables_initializer())
return model
def xDeepFM(feature_dim_dict,
embedding_size=8,
seed=1024,
init_std=0.0001,
l2_reg_linear=0.00001,
l2_reg_embedding=0.00001,
cin_layer_size=(256, 256),
cin_split_half=True,
cin_activation='relu',
hidden_size=(256, 256),
activation='relu',
keep_prob=1,
use_bn=False,
l2_reg_deep=0,
final_activation='sigmoid',
use_video=False,
use_audio=False):
check_feature_config_dict(feature_dim_dict)
deep_emb_list, linear_logit, inputs_list = preprocess_input_embedding(
feature_dim_dict, embedding_size, l2_reg_embedding, l2_reg_linear,
init_std, seed, True)
if use_video:
video_input = tf.keras.layers.Input(shape=(128, ), name='video')
video_emb = tf.keras.layers.Dense(
embedding_size,
use_bias=False,
kernel_regularizer=l2(l2_reg_embedding))(video_input)
video_emb = tf.keras.layers.Reshape(
(1, embedding_size), input_shape=(embedding_size, ))(video_emb)
deep_emb_list.append(video_emb)
inputs_list.append(video_input)
if use_audio:
audio_input = tf.keras.layers.Input(shape=(128, ), name='audio')
audio_emb = tf.keras.layers.Dense(
embedding_size,
use_bias=False,
kernel_regularizer=l2(l2_reg_embedding))(audio_input)
audio_emb = tf.keras.layers.Reshape(
(1, embedding_size), input_shape=(embedding_size, ))(audio_emb)
deep_emb_list.append(audio_emb)
inputs_list.append(audio_input)
fm_input = concat_fun(deep_emb_list, axis=1)
if len(cin_layer_size) > 0:
exFM_out = CIN(cin_layer_size, cin_activation, cin_split_half,
seed)(fm_input)
exFM_logit = tf.keras.layers.Dense(
1,
activation=None,
)(exFM_out)
deep_input = tf.keras.layers.Flatten()(fm_input)
deep_out = MLP(hidden_size, activation, l2_reg_deep, keep_prob, use_bn,
seed)(deep_input)
deep_logit = tf.keras.layers.Dense(1, use_bias=False,
activation=None)(deep_out)
final_logit = tf.keras.layers.add([linear_logit, deep_logit, exFM_logit])
output = PredictionLayer(final_activation, name='output')(final_logit)
model = tf.keras.models.Model(inputs=inputs_list, outputs=output)
return model