情感分类问题IMDB实战(SimpleRNN，LSTM，GRU）_imdb情感分类

作者：人工智能uu | 2024-08-17 13:36:54

踩

imdb情感分类

使用经典的 IMDB 影评数据集来完成情感分类任务。 IMDB 影评数据集包含了50000 条用户评价，评价的标签分为消极和积极，其中 IMDB 评级<5 的用户评价标注为0，即消极； IMDB 评价>=7 的用户评价标注为 1，即积极。 25000 条影评用于训练集，25,000 条用于测试集

一、数据集加载以及数据集预处理


# 加载IMDB数据集，数据采用数字编码，一个数字代表一个单词
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)
print(x_train.shape, len(x_train[0]), y_train.shape)  # (25000,) 218 (25000,)
print(x_test.shape, len(x_test[0]), y_test.shape)  # (25000,) 68 (25000,)
 
# 截断和填充句子，使得等长为max_review_len，此处长句子保留后面部分，短句子在前面填充
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=max_review_len)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=max_review_len)
 
# 构建数据集，打散，批量，并丢掉最后一个不够batches的batch
db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batches, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batches, drop_remainder=True)
print('db_train:', db_train)  # db_train: <BatchDataset shapes: ((128, 80), (128,)), types: (tf.int32, tf.int64)>

通过Keras提供的数据集datasets可以从网上加载IMDB数据集，该数据集一共50000条用户评价，一半用于训练，另一半用于测试。x_train 和 x_test 是长度为 25,000 的一维数组，数组的每个元素是不定长 List，保存了数字编码的每个句子，例如训练集的第一个句子共有 218 个单词，测试集的第一个句子共有 68 个单词，每个句子都包含了句子起始标志 ID。

对于长度参差不齐的句子，设置一个阈值，对大于此长度的句子，选择截断部分单词，可以选择截去句首单词，也可以截去句末单词；对于小于此长度的句子，可以选择在句首或句尾填充，句子截断功能可以通过 keras.preprocessing.sequence.pad_sequences()函数实现

截断或填充为相同长度后，通过 Dataset 类包裹成数据集对象，并添加常用的数据集处理流程，比如数据集批量化，打散，当最后一批数据集不满足一个batch将其丢弃。

二、网络模型构建

自定义网络模型类MyRNN: Embedding层-->两个RNN层-->分类层网络


class MyRNN(keras.Model):
    def __init__(self, units):
        super(MyRNN, self).__init__()
        # 词向量编码 [b,80] ==> [b,80,100]
        # embedding_len：单词向量的长度，total_words：词汇的数量 max_review_len：输入句子长度
        self.embedding = layers.Embedding(total_words, embedding_len, input_length=max_review_len)
        # 构建2个Cell [b,80,100] => [b,64]
        self.rnn = Sequential([
            layers.SimpleRNN(units, dropout=0.5, return_sequences=True),
            layers.SimpleRNN(units, dropout=0.5)
        ])
        # 构建分类网络，用于将Cell的输出特征进行分类，2分类
        # [b,64]=> [b,1]
        self.outlayer = Sequential([
            layers.Dense(units),
            layers.Dropout(rate=0.5),
            layers.ReLU(),
            layers.Dense(1)
        ])
 
    # 向前计算
    def call(self, inputs, training=None):
        x = inputs  # [b,80]
        # embedding: [b,80] ==> [b,80, 100]
        x = self.embedding(x)
        # rnn cell compute: [b, 80,100] => [b,64]
        out1 = self.rnn(x)
        # 末层最后一个输出作为分类网络的输入: [b, 64] => [b, 1]
        x = self.outlayer(out1, training)
        # p(y is pos|x)
        prob = tf.sigmoid(x)
        return prob

Embedding层作用：把单词编码为某个词向量，它接受采用数字编码的单词编号，是可训练的

RNN层：每层都需要上一层在每个时间戳上面的状态输出，因此除了最末层以外，所有的 RNN 层都需要返回每个时间戳上面的状态输出，通过设置 return_sequences=True 来实现，用做下一层的输入，dropout用于优化网络性能：减少层与层之间的连接

分类网络完成 2 分类任务，故输出节点设置为 1。输入序列通过 Embedding 层完成词向量编码，循环通过两个 RNN层，提取语义特征，取最后一层的最后时间戳的状态向量输出送入分类网络，经过Sigmoid 激活函数后得到输出概率
通过Cell方式：


class MyRNN(keras.Model):
    def __init__(self, units):
        super(MyRNN, self).__init__()
        # [b, 64],构建Cell初始化状态向量，重复使用
        self.state0 = [tf.zeros([batches, units])]
        self.state1 = [tf.zeros([batches, units])]
        # 词向量编码 [b,80] ==> [b,80,100]
        self.embedding = layers.Embedding(total_words, embedding_len, input_length=max_review_len)
        # 构建2个Cell
        self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)  # dropout 减少连接
        self.rnn_cell1 = layers.SimpleRNNCell(units, dropout=0.5)
        # 构建分类网络，用于将Cell的输出特征进行分类，2分类
        # [b,80,100] => [b,64]=> [b,1]
        self.outlayer = Sequential([
            layers.Dense(units),
            layers.Dropout(rate=0.5),
            layers.ReLU(),
            layers.Dense(1)
        ])
 
    # 向前计算
    def call(self, inputs, training=None):
        x = inputs  # [b,80]
        # embedding: [b,80] ==> [b,80, 100]
        x = self.embedding(x)
        # rnn cell compute: [b, 80,100] => [b,64]
        state0 = self.state0
        state1 = self.state1
        for word in tf.unstack(x, axis=1):  # word: [b,100] 从时间维度展开
            out0, state0 = self.rnn_cell0(word, state0, training)
            out1, state1 = self.rnn_cell1(out0, state1, training)
        # 末层最后一个输出作为分类网络的输入: [b, 64] => [b, 1]
        x = self.outlayer(out1, training)
        # p(y is pos|x)
        prob = tf.sigmoid(x)
        return prob

需要自己实现向前计算，并且维护各个RNN层的初始状态向量，其他都是一样的

三、网络装配


model = MyRNN(units)
    # 装配优化器，学习率，测量器
    model.compile(optimizer=optimizers.Adam(1e-3),
                  loss=losses.BinaryCrossentropy(),
                  metrics=['accuracy'])

在完成网络模型的搭建后，需要指定网络使用的优化器对象、损失函数类型，评价指标等设定，这一步称为装配为了简便，这里使用 Keras 的 Compile&Fit 方式训练网络，设置优化器为 Adam 优

四、训练与验证


   # 训练 与 验证  validation_data：验证数据
    model.fit(db_train, epochs=epochs, validation_data=db_test)
    # 测试
    model.evaluate(db_test)

这里使用 Keras 的 Compile&Fit 方式训练网络，设置好优化器，学习率，误差函数测试指标(采用准确率)，之间利用fit()喂入数据集和测试集即可训练

结果：训练了近30个epoch

五、LSTM模型

只需要修改网络模型一处即可：修改网络层类型即可


 # 构建rnn
        self.rnn = Sequential([
            layers.LSTM(units, dropout=0.5, return_sequences=True),
            layers.LSTM(units, dropout=0.5)
        ])

结果：LSTM明显效果比RNN好一点

六、GRU模型

只需要修改网络模型一处即可：修改网络层类型即可


  # 构建rnn
        self.rnn = Sequential([
            layers.GRU(units, dropout=0.5, return_sequences=True),
            layers.GRU(units, dropout=0.5)
        ])

结果：也稍微比SampleRNN好：

七、完整程序


# -*- codeing = utf-8 -*-
# @Time : 10:20
# @Author:Paranipd
# @File : imdb_rnn_cell.py
# @Software:PyCharm
 
import os
import tensorflow as tf
import numpy as np
from tensorflow import keras
from tensorflow.keras import Sequential, Model, layers, metrics, optimizers, losses
 
tf.random.set_seed(22)
np.random.seed(22)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2')
 
batches = 128  # 批量大小
total_words = 10000  # 词汇表大小N_vocad
max_review_len = 80  # 句子的最大长度s,大于的部分将截断，小于的将填充
embedding_len = 100  # 词向量特征长度
 
# 加载IMDB数据集，数据采用数字编码，一个数字代表一个单词
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)
print(x_train.shape, len(x_train[0]), y_train.shape)  # (25000,) 218 (25000,)
print(x_test.shape, len(x_test[0]), y_test.shape)  # (25000,) 68 (25000,)
 
 
# 截断和填充句子，使得等长为max_review_len，此处长句子保留后面部分，短句子在前面填充
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=max_review_len)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=max_review_len)
 
# 构建数据集，打散，批量，并丢掉最后一个不够batches的batch
db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batches, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batches, drop_remainder=True)
print('db_train:', db_train)  # db_train: <BatchDataset shapes: ((128, 80), (128,)), types: (tf.int32, tf.int64)>
 
 
class MyRNN(keras.Model):
    def __init__(self, units):
        super(MyRNN, self).__init__()
        # 词向量编码 [b,80] ==> [b,80,100]
        # embedding_len：单词向量的长度，total_words：词汇的数量 max_review_len：输入句子长度
        self.embedding = layers.Embedding(total_words, embedding_len, input_length=max_review_len)
        # 构建2个Cell [b,80,100] => [b,64]
        self.rnn = Sequential([
            layers.SimpleRNN(units, dropout=0.5, return_sequences=True),
            layers.SimpleRNN(units, dropout=0.5)
        ])
        # 构建分类网络，用于将Cell的输出特征进行分类，2分类
        # [b,64]=> [b,1]
        self.outlayer = Sequential([
            layers.Dense(units),
            layers.Dropout(rate=0.5),
            layers.ReLU(),
            layers.Dense(1)
        ])
 
    # 向前计算
    def call(self, inputs, training=None):
        x = inputs  # [b,80]
        # embedding: [b,80] ==> [b,80, 100]
        x = self.embedding(x)
        # rnn cell compute: [b, 80,100] => [b,64]
        out1 = self.rnn(x)
        # 末层最后一个输出作为分类网络的输入: [b, 64] => [b, 1]
        x = self.outlayer(out1, training)
        # p(y is pos|x)
        prob = tf.sigmoid(x)
        return prob
 
 
def main():
    units = 64  # rnn状态向量长度
    epochs = 50
    model = MyRNN(units)
    # 装配优化器，学习率，测量器
    model.compile(optimizer=optimizers.Adam(1e-3),
                  loss=losses.BinaryCrossentropy(),
                  metrics=['accuracy'])
 
    # 训练 与 验证  validation_data：验证数据
    model.fit(db_train, epochs=epochs, validation_data=db_test)
    # 测试
    model.evaluate(db_test)
 
 
if __name__ == '__main__':
    main()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/993007