已知语料划分训练集和测试集，已知词向量预训练模型，比较三种深度学习模型完整代码

这里提供三种深度学习模型的完整代码，分别是CNN、LSTM和Transformer。

## CNN模型

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Embedding, Conv1D, MaxPooling1D
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences

# 加载数据
train_data = np.load('train_data.npy')
train_labels = np.load('train_labels.npy')
test_data = np.load('test_data.npy')
test_labels = np.load('test_labels.npy')

# 参数设置
max_words = 1000
max_len = 100
embedding_dim = 100
filters = 64
kernel_size = 3
pool_size = 2
hidden_dims = 64
batch_size = 32
epochs = 10

# 构建模型
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=max_len))
model.add(Conv1D(filters, kernel_size, padding='valid', activation='relu', strides=1))
model.add(MaxPooling1D(pool_size=pool_size))
model.add(Flatten())
model.add(Dense(hidden_dims))
model.add(Dropout(0.5))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()

# 训练模型
history = model.fit(train_data, train_labels, batch_size=batch_size, epochs=epochs, validation_data=(test_data, test_labels))

# 评估模型
score = model.evaluate(test_data, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

## LSTM模型

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, LSTM, Embedding
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences

# 加载数据
train_data = np.load('train_data.npy')
train_labels = np.load('train_labels.npy')
test_data = np.load('test_data.npy')
test_labels = np.load('test_labels.npy')

# 参数设置
max_words = 1000
max_len = 100
embedding_dim = 100
hidden_dims = 64
batch_size = 32
epochs = 10

# 构建模型
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=max_len))
model.add(LSTM(hidden_dims))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()

# 训练模型
history = model.fit(train_data, train_labels, batch_size=batch_size, epochs=epochs, validation_data=(test_data, test_labels))

# 评估模型
score = model.evaluate(test_data, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

## Transformer模型

import numpy as np
import keras
from keras.models import Model
from keras.layers import Input, Dense, Dropout
from keras.layers import Embedding, Multiply, Lambda
from keras.layers import LayerNormalization, Add
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import keras.backend as K

# 加载数据
train_data = np.load('train_data.npy')
train_labels = np.load('train_labels.npy')
test_data = np.load('test_data.npy')
test_labels = np.load('test_labels.npy')

# 参数设置
max_words = 1000
max_len = 100
embedding_dim = 100
hidden_dims = 64
num_heads = 4
dropout_rate = 0.5
batch_size = 32
epochs = 10

# 定义Multi-head Attention层
class MultiHeadAttention(keras.layers.Layer):
    def __init__(self, num_heads, head_size, dropout_rate=0.0, **kwargs):
        super(MultiHeadAttention, self).__init__(**kwargs)
        self.num_heads = num_heads
        self.head_size = head_size
        self.dropout_rate = dropout_rate
        self.q_dense = Dense(num_heads * head_size, activation=None)
        self.k_dense = Dense(num_heads * head_size, activation=None)
        self.v_dense = Dense(num_heads * head_size, activation=None)
        self.dropout = Dropout(dropout_rate)
        self.output_dense = Dense(head_size * num_heads, activation=None)

    def call(self, inputs):
        q = self.q_dense(inputs)
        k = self.k_dense(inputs)
        v = self.v_dense(inputs)
        q = K.reshape(q, (-1, K.shape(q)[1], self.num_heads, self.head_size))
        q = K.permute_dimensions(q, (0, 2, 1, 3))
        k = K.reshape(k, (-1, K.shape(k)[1], self.num_heads, self.head_size))
        k = K.permute_dimensions(k, (0, 2, 1, 3))
        v = K.reshape(v, (-1, K.shape(v)[1], self.num_heads, self.head_size))
        v = K.permute_dimensions(v, (0, 2, 1, 3))
        score = K.batch_dot(q, K.permute_dimensions(k, (0, 1, 3, 2)))
        score /= K.sqrt(K.cast(self.head_size, dtype=K.floatx()))
        score = K.softmax(score)
        score = self.dropout(score)
        context = K.batch_dot(score, v)
        context = K.permute_dimensions(context, (0, 2, 1, 3))
        context = K.reshape(context, (-1, K.shape(context)[1], self.num_heads * self.head_size))
        output = self.output_dense(context)
        return output

# 定义Transformer Block层
class TransformerBlock(keras.layers.Layer):
    def __init__(self, num_heads, head_size, hidden_dims, dropout_rate=0.0, **kwargs):
        super(TransformerBlock, self).__init__(**kwargs)
        self.mha = MultiHeadAttention(num_heads, head_size, dropout_rate)
        self.dropout1 = Dropout(dropout_rate)
        self.ln1 = LayerNormalization()
        self.dense1 = Dense(hidden_dims, activation='relu')
        self.dropout2 = Dropout(dropout_rate)
        self.dense2 = Dense(head_size * num_heads, activation=None)
        self.dropout3 = Dropout(dropout_rate)
        self.ln2 = LayerNormalization()

    def call(self, inputs):
        x = inputs
        x = self.mha(x)
        x = self.dropout1(x)
        x = Add()([inputs, x])
        x = self.ln1(x)
        y = self.dense1(x)
        y = self.dropout2(y)
        y = self.dense2(y)
        y = self.dropout3(y)
        y = Add()([x, y])
        y = self.ln2(y)
        return y

# 构建模型
input = Input(shape=(max_len,))
x = Embedding(max_words, embedding_dim)(input)
x = Lambda(lambda x: x * np.sqrt(embedding_dim))(x)
x = TransformerBlock(num_heads, hidden_dims // num_heads, hidden_dims, dropout_rate)(x)
x = TransformerBlock(num_heads, hidden_dims // num_heads, hidden_dims, dropout_rate)(x)
x = Flatten()(x)
x = Dense(hidden_dims, activation='relu')(x)
x = Dropout(dropout_rate)(x)
output = Dense(1, activation='sigmoid')(x)
model = Model(inputs=input, outputs=output)

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.summary()

# 训练模型
history = model.fit(train_data, train_labels, batch_size=batch_size, epochs=epochs, validation_data=(test_data, test_labels))

# 评估模型
score = model.evaluate(test_data, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

以上三种模型代码都是基于Keras框架实现的，其中CNN模型和LSTM模型比较简单，而Transformer模型则比较复杂，但也是当前NLP领域最为流行的模型之一。