TensorFlow2实战-系列教程11：RNN文本分类3

机器学习杨卓越

已于 2024-01-30 07:31:28 修改

阅读量567

点赞数 9

分类专栏： TensorFlow 文章标签：深度学习 tensorflow rnn nlp 文本分类

于 2024-01-30 00:50:13 首次发布

本文链接：https://blog.csdn.net/weixin_50592077/article/details/135923743

版权

TensorFlow 专栏收录该内容

16 篇文章 4 订阅

订阅专栏

🧡💛💚TensorFlow2实战-系列教程总目录

有任何问题欢迎在下面留言
本篇文章的代码运行界面均在Jupyter Notebook中进行
本篇文章配套的代码资源已经上传

6、构建训练数据

所有的输入样本必须都是相同shape（文本长度，词向量维度等）
tf.data.Dataset.from_tensor_slices(tensor)：将tensor沿其第一个维度切片，返回一个含有N个样本的数据集，这样做的问题就是需要将整个数据集整体传入，然后切片建立数据集类对象，比较占内存。
tf.data.Dataset.from_generator(data_generator,output_data_type,output_data_shape)：从一个生成器中不断读取样本

def data_generator(f_path, params):
    with open(f_path,encoding='utf-8') as f:
        print('Reading', f_path)
        for line in f:
            line = line.rstrip()
            label, text = line.split('\t')
            text = text.split(' ')
            x = [params['word2idx'].get(w, len(word2idx)) for w in text]#得到当前词所对应的ID
            if len(x) >= params['max_len']:#截断操作
                x = x[:params['max_len']]
            else:
                x += [0] * (params['max_len'] - len(x))#补齐操作
            y = int(label)
            yield x, y

定义一个生成器函数，传进来读数据的路径、和一些有限制的参数，params 在是一个字典，它包含了最大序列长度（max_len）、词到索引的映射（word2idx）等关键信息
打开文件
打印文件路径
遍历每行数据
获取标签和文本
文本按照空格分离出单词
获取当前句子的所有词对应的索引，for w in text取出这个句子的每一个单词，[params[‘word2idx’]取出params中对应的word2idx字典，.get(w, len(word2idx))从word2idx字典中取出该单词对应的索引，如果有这个索引则返回这个索引，如果没有则返回len(word2idx)作为索引，这个索引表示unknow
如果当前句子大于预设的最大句子长度
进行截断操作
如果小于
补充0
标签从str转换为int类型
yield 关键字：用于从一个函数返回一个生成器（generator）。与 return 不同，yield 不会退出函数，而是将函数暂时挂起，保存当前的状态，当生成器再次被调用时，函数会从上次 yield 的地方继续执行，使用 yield 的函数可以在处理大数据集时节省内存，因为它允许逐个生成和处理数据，而不是一次性加载整个数据集到内存中

也就是说yield 会从上一次取得地方再接着去取数据，而return却不会

def dataset(is_training, params):
    _shapes = ([params['max_len']], ())
    _types = (tf.int32, tf.int32)
  
    if is_training:
        ds = tf.data.Dataset.from_generator(
            lambda: data_generator(params['train_path'], params),
            output_shapes = _shapes,
            output_types = _types,)
        ds = ds.shuffle(params['num_samples'])
        ds = ds.batch(params['batch_size'])
        ds = ds.prefetch(tf.data.experimental.AUTOTUNE)
    else:
        ds = tf.data.Dataset.from_generator(
            lambda: data_generator(params['test_path'], params),
            output_shapes = _shapes,
            output_types = _types,)
        ds = ds.batch(params['batch_size'])
        ds = ds.prefetch(tf.data.experimental.AUTOTUNE)
  
    return ds

定义一个制作数据集的函数，is_training表示是否是训练，这个函数在验证和测试也会使用，训练的时候设置为True，验证和测试为False
当前shape值
1
是否在训练，如果是：
构建一个Dataset
传进我们刚刚定义的生成器函数，并且传进实际的路径和配置参数
输出的shape值
输出的类型
指定shuffle
指定 batch_size
设置缓存序列，根据可用的CPU动态设置并行调用的数量，说白了就是加速
如果不是在训练，则：
验证和测试不同的就是路径不同，以及没有shuffle操作，其他都一样
最后把做好的Datasets返回回去

7、自定义网络模型

在这里插入图片描述
一条文本变成一组向量/矩阵的基本流程：

拿到一个英文句子
通过查语料表将句子变成一组索引
通过词嵌入表结合索引将每个单词都变成一组向量，一条句子就变成了一个矩阵，这就是特征了

在这里插入图片描述

BiLSTM即双向LSTM，就是在原本的LSTM增加了一个从后往前走的模块，这样前向和反向两个方向都各自生成了一组特征，把两个特征拼接起来得到一组新的特征，得到翻倍的特征。其他前面和后续的处理操作都是一样的。

class Model(tf.keras.Model):
    def __init__(self, params):
        super().__init__()
        self.embedding = tf.Variable(np.load('./vocab/word.npy'), dtype=tf.float32, name='pretrained_embedding', trainable=False,)
        self.drop1 = tf.keras.layers.Dropout(params['dropout_rate'])
        self.drop2 = tf.keras.layers.Dropout(params['dropout_rate'])
        self.drop3 = tf.keras.layers.Dropout(params['dropout_rate'])

        self.rnn1 = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(params['rnn_units'], return_sequences=True))
        self.rnn2 = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(params['rnn_units'], return_sequences=True))
        self.rnn3 = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(params['rnn_units'], return_sequences=False))
        self.drop_fc = tf.keras.layers.Dropout(params['dropout_rate'])
        self.fc = tf.keras.layers.Dense(2*params['rnn_units'], tf.nn.elu)
        self.out_linear = tf.keras.layers.Dense(2)  
    def call(self, inputs, training=False):
        if inputs.dtype != tf.int32:
            inputs = tf.cast(inputs, tf.int32)
        batch_sz = tf.shape(inputs)[0]
        rnn_units = 2*params['rnn_units']
        x = tf.nn.embedding_lookup(self.embedding, inputs)        
        x = self.drop1(x, training=training)
        x = self.rnn1(x)
        x = self.drop2(x, training=training)
        x = self.rnn2(x)
        x = self.drop3(x, training=training)
        x = self.rnn3(x)
        x = self.drop_fc(x, training=training)
        x = self.fc(x)
        x = self.out_linear(x)
        return x

自定义一个模型，继承tf.keras.Model模块
初始化函数
初始化
词嵌入，把之前保存好的词嵌入文件向量读进来
定义一层dropout1
定义一层dropout2
定义一层dropout3
定义一个rnn1，rnn_units表示得到多少维的特征，return_sequences表示是返回一个序列还是最后一个输出
定义一个rnn2，最后一层的rnn肯定只需要最后一个输出，前后两个rnn的堆叠肯定需要返回一个序列
定义一个rnn3 ，tf.keras.layers.LSTM()直接就可以定义一个LSTM，在外面再封装一层API：tf.keras.layers.Bidirectional就实现了双向LSTM
定义全连接层的dropout
定义一个全连接层，因为是双向的，这里就需要把参数乘以2
定义最后输出的全连接层，只需要得到是正例还是负例，所以是2
定义前向传播函数，传进来一个batch的数据和是否是在训练
如果输入数据不是tf.int32类型
转换成tf.int32类型
取出batch_size
设置LSTM神经元个数，双向乘以2
使用 TensorFlow 的 embedding_lookup 函数将输入的整数索引转换为词向量
数据通过第1个 Dropout 层
数据通过第1个rnn
数据通过第2个 Dropout 层
数据通过第2个rnn
数据通过第3个 Dropout 层
数据通过第3个rnn
经过全连接层对应的Dropout
数据通过一个全连接层
最后，数据通过一个输出层
返回最终的模型输出