机器学习-循环神经网络情感分类问题（二）

本篇主要应用SimpleRNN实现了对于循环神经网络情感分类问题的代码讲解，初学者可以先看前一篇的基础内容讲解再来看本篇会有更清楚的认识。

机器学习-循环神经网络入门（一）

目录

数据处理：

构建输入数据：

数据集的构建：

自定义模型类MyRNN：

SimpleRNNCell:

主函数：

---

数据处理：

batchsz = 512 # 批量大小
total_words = 10000 # 词汇表大小N_vocab
max_review_len = 80 # 句子最大长度s，大于的句子部分将截断，小于的将填充
embedding_len = 100 # 词向量特征长度f
# 加载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)
print(x_test.shape, len(x_test[0]), y_test.shape)
x_train[0]
# 数字编码表
word_index = keras.datasets.imdb.get_word_index()
word_index = {k:(v+3) for k,v in word_index.items()}
word_index[""] = 0 #填充标志
word_index[""] = 1 #起始标志
word_index[""] = 2  # 未知单词标志
word_index[""] = 3 #尚未使用的一位
# 翻转编码表
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])

情感分类问题需要使用IMDB数据集，直接下载即可。

词汇表的大小为10000，即可以识别不同的10000个单词。设置句子最大长度为80，截断与填充后面有函数实现，到后面再讲。此处的重点是数据的编码表，如果你查看编码表会发现是以单词为索引，值为数字ID，和我们预期的不符；我们需要的是以ID为索引，以单词为值，并为id添加特殊的标志位。

---

构建输入数据：

def decode_review(text):
    return ' '.join([reverse_word_index.get(i, '?') for i in text])

我们可以通过该函数将以数字编码的句子转化为字符串数据

---

数据集的构建：

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)

db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batchsz, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batchsz, drop_remainder=True)
print('x_train shape:', x_train.shape, tf.reduce_max(y_train), tf.reduce_min(y_train))
print('x_test shape:', x_test.shape)

已经在上面因如果数据集，这里对数据集进行优化，便于后面使用。截断和填充句子，使句子都等长，长句子保留后面的，短句子在前面填充。训练集和测试集都进行同样的操作，并将其都变为数据集对象，打乱；进行分批处理要注意drop_remainder，为true的时候表示丢掉最后一个分批，因为它的大小会小于正常分批大小。

---

自定义模型类MyRNN：

class MyRNN(keras.Model):
    # Cell方式构建多层网络
    def __init__(self, units):
        super(MyRNN, self).__init__() 
        # 词向量编码 [b, 80] => [b, 80, 100]
        self.embedding = layers.Embedding(total_words, embedding_len,
                                          input_length=max_review_len)
        # 构建RNN 直接构建RNN，除最后一层外，其他层要返回所有时间戳的输出列表
        self.rnn = keras.Sequential([
            layers.SimpleRNN(units, dropout=0.5, return_sequences=True),
            layers.SimpleRNN(units, dropout=0.5)
        ])
        # 构建分类网络，用于将CELL的输出特征进行分类，2分类
        # [b, 80, 100] => [b, 64] => [b, 1]
        self.outlayer = Sequential([
        	layers.Dense(32),
        	layers.Dropout(rate=0.5),
        	layers.ReLU(),
        	layers.Dense(1)])

对多层网络进行构建，最先是embedding层，目的是实现单词的向量化，设定单词向量长度为100，因此经过embedding层后输出为[批，80,100]。

接着构建RNN网络：此处直接使用SimpleRNN，在内部实现多层Cell。units是经过RNN变换后的单词向量长度，设置dropout是防止过拟合，return_sequences为true表明中间层的输出也要输出出来，末层直接作为整个网络的输出了。最终输出为[批，units]。

在这里简单介绍一下dropout：是为了防止过拟合而出现的，它可以作为一个单独的层而出现，具体内容为：在训练的时候有p的概率断开某条连接，以减少实际参与计算的模型数量，而在最终的测试时不予断开，以最好的性能性能参与测试。如此一来可以减少过拟合，提高泛化能力。个人觉得dropout层是为了对神经网络进行优化，而不是必不可少的。

情感分类是一个二分类问题，因此最终经过全连接层只要一个输出就行。

    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]
        x = self.rnn(x) #两层RNN，输入x，直接有输出，不用一层一层的看
        # 末层最后一个输出作为分类网络的输入: [b, 64] => [b, 1]
        x = self.outlayer(x,training)
        # p(y is pos|x)
        prob = tf.sigmoid(x)

        return prob

embedding层规定输入长度为80，并且我们之前对数据集进行了长度规定，因此输入就是[批，80]，经过embedding层变为[批，80，100]，经过两次RNN得到[批，64],经过全连接层得到输入了一个training,表示是训练集，dropout起作用，输出为[批，1]。最终输出经过sigmoid函数激活得到概率。注意我们此处使用的是SimpleRNN而不是SimpleRNNCell，因此在内部已经有多个Cell，此处只需要调用神经网络而不需要去管次数。

大家在学习神经网络相关内容时要注意每层输入是什么形状，输出是什么形状的，这至关重要。

SimpleRNNCell:

作为类比，我在下面添加关于SimpleRNNCell的代码，大家可以进行类比，增强理解与记忆。

        self.state0 = [tf.zeros([batchsz, units])]
        self.state1 = [tf.zeros([batchsz, units])]
# 构建2个Cell 直接构建两个cell，添加dropout防止过拟合
        self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)
        self.rnn_cell1 = layers.SimpleRNNCell(units, dropout=0.5)

 先是对SimpleRNNCell进行构建，一共两个层。对初始的状态向量进行初始化。其余内容和SimpleRNN基本类似。

 def call(self, inputs, training=None):
        x = inputs # [b, 80]
        # embedding: [b, 80] => [b, 80, 100] 将x输入embedding层进行向量化
        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] b个句子，每个单词长100
            out0, state0 = self.rnn_cell0(word, state0, training)
            #经过cell层计算得到的是h状态向量输出，长度为64即[b,64];word相当于输入x，state0是初始化的状态向量
            out1, state1 = self.rnn_cell1(out0, state1, training)
            #上一层输出的状态向量out0作为输入，进入该层。
        # 末层最后一个输出作为分类网络的输入: [b, 64] => [b, 1]
        x = self.outlayer(out1, training)
        # p(y is pos|x)
        prob = tf.sigmoid(x)

        return prob

 除了输入x要经过embedding编码外，获得初始状态向量，对x在句子中单词个数维度进行循环，总共循环次数就是单词个数次，即需要调用这么多次个SimpleRNNCell。一共是两层Cell，一次循环表示在一个时间戳上输入在所有层上的传播。再次强调循环的次数就是时间戳的个数，也就是每句话单词的数量。在此我需要强调：一整个循环神经网络的输入还是那么多个单词，并未改变。此处的例子是两个Cell层，其中第一层的输入是外界输入（也就是需要分析的单词）和一个状态向量，第二层输入是第一层的输出和状态向量，不再涉及到外界输入的单词，如果有第三层第四层也是类似。添加Cell只是在深度层面加深，循环次数没有改变。

---

主函数：

def main():
    units = 64 # RNN状态向量长度f
    epochs = 50 # 训练epochs

    model = MyRNN(units)
    # 装配
    model.compile(optimizer = optimizers.Adam(0.001),
                  loss = losses.BinaryCrossentropy(),
                  metrics=['accuracy'])
    # 训练和验证
    model.fit(db_train, epochs=epochs, validation_data=db_test)
    # 测试
    model.evaluate(db_test)

给定RNN状态向量长度，训练轮次数。compile()表示装配过程：函数指定网络使用的优化器对象、损失函数类型，评价指标等。模型装配完成后，即可通过 fit()函数送入待训练的数据集和验证用的数据集，这一步称为模型训练。evaluate()：模型测试，测试在 db_test 上的性能表现.