def FiBiNet(feature_metas,
interaction_mode='all',
interaction_mode_se='all',
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='FiBiNet'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None)
inputs = list(embedded_dict.values())
interactions = BiInteraction(mode=interaction_mode)(inputs)
inputs_se = SENet(axis=-1)(tf.stack(inputs, axis=1))
interactions_se = BiInteraction(mode=interaction_mode_se)(split_tensor(
inputs_se, axis=1))
dnn_inputs = tf.concat([interactions, interactions_se], axis=1)
dnn_output = DNN(units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(dnn_inputs)
# Output
output = tf.keras.activations.sigmoid(dnn_output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def train_network(vectorizer, network_type, task_type, train_table,
setting_name):
"""
Main function of vectorization for neural network
network_type : str
type of the network, which should be presented in NETWORKS dictionary.
task_type : str
TTK_TASK or BANK_TASK
train_table : str
Train table filepath
returns : None
"""
message_settings, features_settings = utils.load_embeddings()
features = Features(TwitterMessageParser(message_settings, task_type),
features_settings)
term_vocabulary = TermVocabulary()
doc_vocabulary = DocVocabulary()
problem = utils.create_problem(task_type, 'train', train_table, vectorizer,
features, term_vocabulary, doc_vocabulary,
message_settings)
assert (len(problem) > 0)
X, y = get_problem(problem, get_results=True)
embedding_size = X.shape[1]
logging.info("embedding_size: {}".format(embedding_size))
logging.info("Create RNN network model ...")
# TODO:
# Network setting should be presented in json configuration (apperently
# rnn.conf)
hidden_size = 400
model = get_network(network_type, embedding_size, hidden_size)
paths = get_model_paths(task_type, network_type, setting_name)
logging.info("Pack embedding settings: {} ...".format(
paths['embedding_output']))
save_embeddings(paths['embedding_output'])
logging.info("Save term vocabulary: {} ...".format(
paths['term_vocabulary']))
term_vocabulary.save(paths['term_vocabulary'])
optimizer.train_network(model, X, y, paths['model_output'])
def FNN(feature_metas,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='FNN'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
inputs = features.gen_concated_feature(
embedding_group='embedding',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None)
output = DNN(units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(inputs)
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def MLR(feature_metas,
regions=10,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
name='MLR'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
inputs = features.gen_concated_feature(
embedding_group='embedding',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None)
region_values = tf.keras.layers.Dense(
units=regions,
kernel_initializer=tf.keras.initializers.RandomNormal(),
kernel_regularizer=tf.keras.regularizers.l2())(inputs)
region_values = tf.keras.activations.sigmoid(region_values)
region_weights = tf.keras.layers.Dense(
units=regions,
kernel_initializer=tf.keras.initializers.RandomNormal(),
kernel_regularizer=tf.keras.regularizers.l2())(inputs)
region_weights = tf.keras.layers.Softmax()(region_weights)
output = tf.reduce_sum(tf.multiply(region_values, region_weights),
axis=-1,
keepdims=True)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def prepare_problem(vectorizer, task_type, train_table, test_table,
etalon_table):
"""
Main function of vectorization for neural network
"""
message_settings, features_settings = utils.load_embeddings()
features = Features(TwitterMessageParser(message_settings, task_type),
features_settings)
term_vocabulary = TermVocabulary()
doc_vocabulary = DocVocabulary()
train_problem = utils.create_problem(task_type, 'train', train_table,
vectorizer, features, term_vocabulary,
doc_vocabulary, message_settings)
test_problem = utils.create_problem(task_type, 'test', test_table,
vectorizer, features, term_vocabulary,
doc_vocabulary, message_settings)
return (train_problem, test_problem)
'vectorizer_type': sys.argv[2],
'network_type': sys.argv[3],
'task_type': sys.argv[4],
'test_table': sys.argv[5],
'model_out': sys.argv[6]}
task_type = config['task_type']
network_type = config['network_type']
paths = get_model_paths(task_type, network_type, config['setting_name'])
# loading model
model, features_settings, message_settings, term_vocabulary = \
load_model(paths)
features = Features(
TwitterMessageParser(message_settings, task_type),
features_settings)
doc_vocabulary = DocVocabulary()
problem = utils.create_problem(task_type,
'test',
config['test_table'],
get_vectorizer(config['vectorizer_type']),
features,
term_vocabulary,
doc_vocabulary,
message_settings)
# Preparing X dataset
X = get_problem(problem, get_results=False)
def DCN(
feature_metas,
cross_kernel_initializer='glorot_uniform',
cross_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
cross_bias_initializer='zeros',
cross_bias_regularizer=None,
cross_layers_num=3,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='Deep&CrossNetwork'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None
)
# Deep Part
deep_inputs = features.gen_concated_feature(
embedding_group='embedding',
fixed_embedding_dim=fixed_embedding_dim,
slots_filter=None
)
deep_output = DNN(
units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers
)(deep_inputs)
# Cross Part
cross_inputs = list(embedded_dict.values())
cross_output = CrossNetwork(
kernel_initializer=cross_kernel_initializer,
kernel_regularizer=cross_kernel_regularizer,
bias_initializer=cross_bias_initializer,
bias_regularizer=cross_bias_regularizer
)(cross_inputs, layers_num=cross_layers_num, require_logit=True)
output = tf.keras.activations.sigmoid(deep_output + cross_output)
model = tf.keras.Model(inputs=features.get_inputs_list(), outputs=output)
return model
def NFFM(
feature_metas,
biinteraction_mode='all',
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fm_fixed_embedding_dim=None,
linear_use_bias=True,
linear_kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-4, seed=1024),
linear_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='NFFM'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
# Linear Part
with tf.name_scope('Linear'):
linear_output = features.get_linear_logit(use_bias=linear_use_bias,
kernel_initializer=linear_kernel_initializer,
kernel_regularizer=linear_kernel_regularizer,
embedding_group='dot_embedding',
slots_filter=None)
# Interaction Part
with tf.name_scope('Interaction'):
fm_embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fm_fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None
)
fm_dim_groups = group_embedded_by_dim(fm_embedded_dict)
interactions = list()
for fm_group in fm_dim_groups.values():
group_interaction = BiInteraction(mode=biinteraction_mode)(fm_group)
interactions.append(group_interaction)
interactions = tf.concat(interactions, axis=1)
dnn_output = DNN(
units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers
)(interactions)
# Output
output = tf.add_n([linear_output, dnn_output])
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(), outputs=output)
return model
def WideAndDeep(
feature_metas,
wide_slots,
deep_slots,
embedding_initializer=tf.keras.initializers.RandomNormal(mean=0.0, stddev=1e-4),
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
wide_use_bias=True,
wide_kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-4, seed=1024),
wide_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
deep_fixed_embedding_dim=None,
deep_hidden_units=(128, 64, 1),
deep_activations=('relu', 'relu', None),
deep_use_bias=True,
deep_use_bn=False,
deep_dropout=0,
deep_kernel_initializers='glorot_uniform',
deep_bias_initializers='zeros',
deep_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
deep_bias_regularizers=None,
name='Wide&Deep'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
# Wide Part
with tf.name_scope('Wide'):
wide_output = features.get_linear_logit(embedding_group='dot_embedding',
use_bias=wide_use_bias,
kernel_initializer=wide_kernel_initializer,
kernel_regularizer=wide_kernel_regularizer,
slots_filter=wide_slots)
# Deep Part
with tf.name_scope('Deep'):
deep_inputs = features.gen_concated_feature(embedding_group='embedding',
fixed_embedding_dim=deep_fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=deep_slots)
deep_output = DNN(
units=deep_hidden_units,
use_bias=deep_use_bias,
activations=deep_activations,
use_bn=deep_use_bn,
dropout=deep_dropout,
kernel_initializers=deep_kernel_initializers,
bias_initializers=deep_bias_initializers,
kernel_regularizers=deep_kernel_regularizers,
bias_regularizers=deep_bias_regularizers
)(deep_inputs)
# Output
output = tf.add_n([wide_output, deep_output])
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(), outputs=output)
return model
def AFM(feature_metas,
linear_slots,
fm_slots,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fm_fixed_embedding_dim=None,
linear_use_bias=True,
linear_kernel_initializer=tf.keras.initializers.RandomNormal(
stddev=1e-4, seed=1024),
linear_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='AFM'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
# Linear Part
with tf.name_scope('Linear'):
linear_output = features.get_linear_logit(
use_bias=linear_use_bias,
kernel_initializer=linear_kernel_initializer,
kernel_regularizer=linear_kernel_regularizer,
embedding_group='dot_embedding',
slots_filter=linear_slots)
# Interaction
with tf.name_scope('Interaction'):
fm_embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fm_fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=fm_slots)
# print(fm_embedded_dict)
fm_dim_groups = group_embedded_by_dim(fm_embedded_dict)
fms = [
AttentionBasedPoolingLayer()(group)
for group in fm_dim_groups.values() if len(group) > 1
]
print("fms", fms)
dnn_inputs = tf.concat(fms, axis=1)
print("dnn_inputs", dnn_inputs)
dnn_output = DNN(
units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(dnn_inputs)
# Output
output = tf.add_n([linear_output, dnn_output])
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def DeepFM(
feature_metas,
linear_slots,
fm_slots,
dnn_slots,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fm_fixed_embedding_dim=None,
linear_use_bias=True,
#按照正态分布生成随机张量的初始化器。
linear_kernel_initializer=tf.keras.initializers.RandomNormal(
stddev=1e-4, seed=1024),
linear_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='DeepFM'):
# 检测是否是feature__metas类型是否是FeatrueMetas;
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
#print(features.shape)
# Linear Part
with tf.name_scope('Linear'):
#
linear_output = features.get_linear_logit(
use_bias=linear_use_bias,
kernel_initializer=linear_kernel_initializer,
kernel_regularizer=linear_kernel_regularizer,
embedding_group='dot_embedding',
slots_filter=linear_slots)
# FM Part
with tf.name_scope('FM'):
fm_embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fm_fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=fm_slots)
fm_dim_groups = group_embedded_by_dim(fm_embedded_dict)
fms = [
FM()(group) for group in fm_dim_groups.values()
if len(group) > 1
]
fm_output = tf.add_n(fms)
# DNN Part
with tf.name_scope('DNN'):
dnn_inputs = features.gen_concated_feature(
embedding_group='embedding',
fixed_embedding_dim=fm_fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=dnn_slots)
dnn_output = DNN(
units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(dnn_inputs)
# Output 将计算矩阵进行拼接
output = tf.add_n([linear_output, fm_output, dnn_output])
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def vectorization_core(vectorizer,
init_term_vocabulary=True,
merge_doc_vocabularies=False):
"""
Main function of collection vectorization
vectorizer : message vectorization function
returns : None
"""
init_logger()
if (sys.argv < 8):
exit(0)
config = {
'task_type': sys.argv[1],
'database': sys.argv[2], # save the output results
'train_table': sys.argv[3],
'test_table': sys.argv[4],
'train_output': sys.argv[5],
'test_output': sys.argv[6],
'pconf_output': sys.argv[7]
}
with io.open(configs.TWITTER_MESSAGE_PARSER_CONFIG, "r") as f:
message_settings = json.load(f, encoding='utf-8')
with io.open(configs.FEATURES_CONFIG, 'r') as f:
features_settings = json.load(f, encoding='utf-8')
# Create vocabulary of terms
if init_term_vocabulary is True:
term_vocabulary = core.indexer.create_term_vocabulary(
[config['train_table'], config['test_table']], message_settings)
else:
term_vocabulary = TermVocabulary()
features = Features(
TwitterMessageParser(message_settings, config['task_type']),
features_settings)
doc_vocabulary = DocVocabulary()
# Train problem
train_problem = create_problem(config['task_type'], 'train',
config['train_table'], vectorizer, features,
term_vocabulary, doc_vocabulary,
message_settings)
if not merge_doc_vocabularies:
doc_vocabulary = DocVocabulary()
# Test problem
test_problem = create_problem(config['task_type'], 'test',
config['test_table'], vectorizer, features,
term_vocabulary, doc_vocabulary,
message_settings)
result_table = config['test_table'] + '.result.csv'
logging.info(
'Create a file for classifier results: {}'.format(result_table))
result_df = pd.read_csv(config['test_table'], sep=',')
result_df.to_csv(result_table, sep=',')
# Save
save_problem(train_problem, config['train_output'])
save_problem(test_problem, config['test_output'])
save_predict_config(columns=get_score_columns(config['task_type']),
prediction_table=result_table,
out_filepath=config['pconf_output'])
def AutoInt(feature_metas,
seed=2333,
interaction_layer_num=3,
attention_embedding_size=8,
attention_heads=2,
interaction_use_res=True,
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='AutoInt'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
embedded_dict = features.get_embedded_dict(
slots_filter=None,
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
group_name='embedding')
grouped_embedded = group_embedded_by_dim(embedded_dict)
grouped_inputs = [
tf.stack(group, axis=1) for group in grouped_embedded.values()
]
for _ in range(interaction_layer_num):
for i in range(len(grouped_inputs)):
grouped_inputs[i] = AutoIntInteraction(
att_embedding_size=attention_embedding_size,
heads=attention_heads,
use_res=interaction_use_res,
seed=seed)(grouped_inputs[i])
dnn_inputs = tf.keras.layers.Flatten()(tf.concat(grouped_inputs,
axis=2))
output = DNN(units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(dnn_inputs)
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model
def FGCNN(
feature_metas,
fg_filters=(14, 16, 18, 20),
fg_widths=(7, 7, 7, 7),
fg_pool_widths=(2, 2, 2, 2),
fg_new_feat_filters=(3, 3, 3, 3),
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=8,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='FGCNN'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
raw_feats = features.get_stacked_feature(
embedding_group='raw',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None
)
fg_inputs = features.get_stacked_feature(
embedding_group='fgcnn',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None
)
fg_inputs = tf.expand_dims(fg_inputs, axis=-1)
new_feats_list = list()
for filters, width, pool, new_filters in zip(fg_filters, fg_widths, fg_pool_widths, fg_new_feat_filters):
fg_inputs, new_feats = FGCNNlayer(
filters=filters,
kernel_width=width,
pool_width=pool,
new_feat_filters=new_filters
)(fg_inputs)
new_feats_list.append(new_feats)
inputs = tf.concat(new_feats_list + [raw_feats], axis=1)
inputs = split_tensor(inputs, axis=1)
inputs_fm = InnerProduct(require_logit=False)(inputs)
dnn_inputs = tf.concat(inputs + [inputs_fm], axis=1)
output = DNN(
units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers
)(dnn_inputs)
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(), outputs=output)
return model
def PNN(feature_metas,
use_inner_product=True,
use_outer_product=False,
outer_kernel_initializer='glorot_uniform',
outer_kernel_regularizer=tf.keras.regularizers.l2(1e-5),
embedding_initializer='glorot_uniform',
embedding_regularizer=tf.keras.regularizers.l2(1e-5),
fixed_embedding_dim=None,
dnn_hidden_units=(128, 64, 1),
dnn_activations=('relu', 'relu', None),
dnn_use_bias=True,
dnn_use_bn=False,
dnn_dropout=0,
dnn_kernel_initializers='glorot_uniform',
dnn_bias_initializers='zeros',
dnn_kernel_regularizers=tf.keras.regularizers.l2(1e-5),
dnn_bias_regularizers=None,
name='PNN'):
assert isinstance(feature_metas, FeatureMetas)
with tf.name_scope(name):
features = Features(metas=feature_metas)
embedded_dict = features.get_embedded_dict(
group_name='embedding',
fixed_embedding_dim=fixed_embedding_dim,
embedding_initializer=embedding_initializer,
embedding_regularizer=embedding_regularizer,
slots_filter=None)
raw_embedded_inputs = features.gen_concated_feature(
embedding_group='embedding',
fixed_embedding_dim=fixed_embedding_dim,
slots_filter=None)
inputs = [raw_embedded_inputs]
if use_inner_product:
inner_product_inputs = InnerProduct()(list(embedded_dict.values()))
inputs.append(inner_product_inputs)
if use_outer_product:
outer_product_inputs = OuterProduct(
outer_kernel_regularizer=outer_kernel_regularizer,
outer_kernel_initializer=outer_kernel_initializer)(list(
embedded_dict.values()))
inputs.append(outer_product_inputs)
inputs = tf.concat(inputs, axis=1)
output = DNN(units=dnn_hidden_units,
use_bias=dnn_use_bias,
activations=dnn_activations,
use_bn=dnn_use_bn,
dropout=dnn_dropout,
kernel_initializers=dnn_kernel_initializers,
bias_initializers=dnn_bias_initializers,
kernel_regularizers=dnn_kernel_regularizers,
bias_regularizers=dnn_bias_regularizers)(inputs)
output = tf.keras.activations.sigmoid(output)
model = tf.keras.Model(inputs=features.get_inputs_list(),
outputs=output)
return model