对应的tensorflow版本：2.5.0+

textcnn模型如下：

import tensorflow as tf


class ConvMaxPooling1d(tf.keras.layers.Layer):
    def __init__(self, filters, kernel):
        super(ConvMaxPooling1d, self).__init__()
        self.kernel_size = kernel
        #(batch_size, step, embedding_size)->(batch_size,step-kernel_size+1,filter_size)
        self.conv = tf.keras.layers.Conv1D(filters=filters, kernel_size=kernel, activation='relu')
        # (batch_size,step-kernel_size+1,filter_size)->(batch_size,filter_size)
        self.pool = tf.keras.layers.GlobalMaxPool1D()
        tf.random.uniform()

    def call(self, inputs, masks=None):
        conv_out = self.conv(inputs)
        pool_out = self.pool(conv_out)
        return pool_out


class TextCNN(tf.keras.models.Model):
    def __init__(self, vocab, embedding_size, hidden_size, filters_list=[50 ,60, 70, 80], kernels=[2,3, 4, 5],
                 dropout=0.5, sentence_length=20):
        super(TextCNN, self).__init__()
        ind = tf.feature_column.categorical_column_with_vocabulary_file("sentence_vocab", vocabulary_file=vocab,
                                                                        default_value=0)
        self.embedding_size = embedding_size
        self.sentence_length = sentence_length
        self.dense_feature_layer = tf.keras.layers.DenseFeatures(
            [tf.feature_column.embedding_column(ind, dimension=embedding_size)])

        self.conv_maxs = [ConvMaxPooling1d(f, k) for f, k in zip(filters_list, kernels)]
        self.dropout = tf.keras.layers.Dropout(dropout)
        self.dense = tf.keras.layers.Dense(hidden_size, activation='relu')
        self.classifier = tf.keras.layers.Dense(1, activation='sigmoid')

    # @tf.function(input_signature=(tf.TensorSpec(shape=(None, None), dtype=tf.dtypes.string),))
    def call(self, inputs):
        # ***************word token embedding begin***************
        inputs = tf.convert_to_tensor(inputs)
        inputs_tensor = tf.reshape(inputs, (-1, 1))
        embed_word_vectors1 = self.dense_feature_layer({"sentence_vocab": inputs_tensor})
        embeddings = tf.reshape(embed_word_vectors1, (-1, self.sentence_length, self.embedding_size))
        # ***************word token embedding end***************
        #对于每一个layer来说，输入是：(batch_size,step,embedding_size)->(batch_size,step-kernel_size+1,filter_size)
        conv_outs = [layer(embeddings, None) for layer in self.conv_maxs]
        # 对于每一个layer来说，输入是：[(batch_size,step-kernel_size+1,filter_size)]->(batch_size,step-kernel_size+1,sum(filter_size))
        concat_out = tf.concat(conv_outs, axis=-1)
        dense_out = self.dense(concat_out)
        drop_out = self.dropout(dense_out)
        logits = self.classifier(drop_out)

        return logits

模型训练代码如下：

import tensorflow as tf

from model.TextCNN import TextCNN
from utils.path_utils import get_full_path
from utils.read_batch_data import get_data


class SingleRNNModelTest:
    def __init__(self,
                 epoch=3,
                 batch_size=100,
                 embedding_size=256,
                 learning_rate=0.001,
                 model_path="model_version",
                 sentence_vocb_length=20,
                 fill_vocab='TTTTTT',
                 vocab_file_path="data/vocab_clean.txt"
                 ):
        self.optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
        self.loss = tf.keras.losses.BinaryCrossentropy(reduction=tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE)
        self.epoch = epoch
        self.batch_size = batch_size
        self.model_path = model_path
        self.sentence_vocb_length = sentence_vocb_length
        self.fill_vocab = fill_vocab

        self.model = TextCNN(vocab=get_full_path(vocab_file_path), embedding_size=embedding_size, hidden_size=20,
                             sentence_length=sentence_vocb_length)
        self.summary_writer = tf.summary.create_file_writer('./tensorboard/news_label_model/{}'.format(model_path))


    def train(self):
        # ========================== Create dataset =======================

        train_x,train_y = get_data("data/train_data/prepare/train_data_v2.txt", self.sentence_vocb_length, self.fill_vocab)
        self.model(train_x)
        board = tf.keras.callbacks.TensorBoard(log_dir=get_full_path("data/fit_log/graph"), write_graph=True)
        model_save = tf.keras.callbacks.ModelCheckpoint(get_full_path("data/fit_log/fit_model3"), monitor="val_loss",
                                                        mode="min")
        self.model.compile(optimizer=self.optimizer, loss=self.loss,
                           metrics=[tf.keras.metrics.BinaryAccuracy(threshold=0.5),
                                    tf.keras.metrics.AUC(curve='PR', name='p-r'),
                                    tf.keras.metrics.AUC(curve='ROC', name='ROC'),
                                    ])
        self.model.fit(x=train_x,y=train_y,batch_size=self.batch_size, epochs=self.epoch,shuffle=True,callbacks=[board, model_save])

if __name__ == '__main__':
    # =============================== GPU ==============================
    gpu = tf.config.experimental.list_physical_devices(device_type='GPU')
    print("gpu message:{}".format(gpu))
    # If you have GPU, and the value is GPU serial number.
    import os

    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"

    epoch = 20
    batch_size = 1000
    sentence_vocb_length = 25
    embedding_size = 216
    learning_rate = 0.001

    train_instance = SingleRNNModelTest(epoch=epoch, batch_size=batch_size, sentence_vocb_length=sentence_vocb_length,
                                        embedding_size=embedding_size, learning_rate=learning_rate)

    train_instance.train()