PNN.py

import tensorflow as tf

from core.features import FeatureMetas, Features
from core.blocks import DNN, InnerProduct, OuterProduct


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