使用飞桨实现基于LSTM的情感分析模型

    • 数据处理：选择需要使用的数据，并做好必要的预处理工作。

    • 网络定义：使用飞桨定义好网络结构，包括输入层，中间层，输出层，损失函数和优化算法。

    • 网络训练：将准备好的数据送入神经网络进行学习，并观察学习的过程是否正常，如损失函数值是否在降低，也可以打印一些中间步骤的结果出来等。

    • 网络评估：使用测试集合测试训练好的神经网络，看看训练效果如何。

    在数据处理前，需要先加载飞桨平台（如果用户在本地使用，请确保已经安装飞桨）。

    2.     #通过python的requests类，下载存储在
    3.     #https://dataset.bj.bcebos.com/imdb%2FaclImdb_v1.tar.gz的文件
    4.     corpus_url = "https://dataset.bj.bcebos.com/imdb%2FaclImdb_v1.tar.gz"
    5.     web_request = requests.get(corpus_url)
    6.     corpus = web_request.content
    8.     #将下载的文件写在当前目录的aclImdb_v1.tar.gz文件内
    9.     with open("./aclImdb_v1.tar.gz", "wb") as f:
    10.         f.write(corpus)
    11.     f.close()
    13. download()

    接下来，将数据集加载到程序中，并打印一小部分数据观察一下数据集的特点，代码如下：

    1. def load_imdb(is_training):
    2.     data_set = []
    4.     #aclImdb_v1.tar.gz解压后是一个目录
    5.     #我们可以使用python的rarfile库进行解压
    6.     #训练数据和测试数据已经经过切分，其中训练数据的地址为：
    7.     #./aclImdb/train/pos/ 和 ./aclImdb/train/neg/，分别存储着正向情感的数据和负向情感的数据
    8.     #我们把数据依次读取出来，并放到data_set里
    9.     #data_set中每个元素都是一个二元组，（句子，label），其中label=0表示负向情感，label=1表示正向情感
    11.     for label in ["pos", "neg"]:
    12.         with tarfile.open("./aclImdb_v1.tar.gz") as tarf:
    13.             path_pattern = "aclImdb/train/" + label + "/.*\.txt$" if is_training \
    14.                 else "aclImdb/test/" + label + "/.*\.txt$"
    15.             path_pattern = re.compile(path_pattern)
    16.             tf = tarf.next()
    17.             while tf != None:
    18.                 if bool(path_pattern.match(tf.name)):
    19.                     sentence = tarf.extractfile(tf).read().decode()
    20.                     sentence_label = 0 if label == 'neg' else 1
    21.                     data_set.append((sentence, sentence_label)) 
    22.                 tf = tarf.next()
    24.     return data_set
    26. train_corpus = load_imdb(True)
    27. test_corpus = load_imdb(False)
    29. for i in range(5):
    30.     print("sentence %d, %s" % (i, train_corpus[i][0]))    
    31.     print("sentence %d, label %d" % (i, train_corpus[i][1]))

    一般来说，在自然语言处理中，需要先对语料进行切词，这里我们可以使用空格把每个句子切成若干词的序列，代码如下：

    在经过切词后，需要构造一个词典，把每个词都转化成一个ID，以便于神经网络训练。代码如下：

    注意：

    在代码中我们使用了一个特殊的单词"[oov]"（out-of-vocabulary），用于表示词表中没有覆盖到的词。之所以使用"[oov]"这个符号，是为了处理某一些词，再测试数据中有，但训练数据没有的现象。

    1. #构造词典，统计每个词的频率，并根据频率将每个词转换为一个整数id
    2. def build_dict(corpus):
    3.     word_freq_dict = dict()
    4.     for sentence, _ in corpus:
    5.         for word in sentence:
    6.             if word not in word_freq_dict:
    7.                 word_freq_dict[word] = 0
    8.             word_freq_dict[word] += 1
    10.     word_freq_dict = sorted(word_freq_dict.items(), key = lambda x:x[1], reverse = True)
    12.     word2id_dict = dict()
    13.     word2id_freq = dict()
    15.     #一般来说，我们把oov和pad放在词典前面，给他们一个比较小的id，这样比较方便记忆，并且易于后续扩展词表
    16.     word2id_dict['[oov]'] = 0
    17.     word2id_freq[0] = 1e10
    19.     word2id_dict['[pad]'] = 1
    20.     word2id_freq[1] = 1e10
    22.     for word, freq in word_freq_dict:
    23.         word2id_dict[word] = len(word2id_dict)
    24.         word2id_freq[word2id_dict[word]] = freq
    26.     return word2id_freq, word2id_dict
    28. word2id_freq, word2id_dict = build_dict(train_corpus)
    29. vocab_size = len(word2id_freq)
    30. print("there are totoally %d different words in the corpus" % vocab_size)
    31. for _, (word, word_id) in zip(range(50), word2id_dict.items()):
    32.     print("word %s, its id %d, its word freq %d" % (word, word_id, word2id_freq[word_id]))

    在完成word2id词典假设之后，我们还需要进一步处理原始语料，把语料中的所有句子都处理成ID序列，代码如下：

    1. #把语料转换为id序列
    2. def convert_corpus_to_id(corpus, word2id_dict):
    3.     data_set = []
    4.     for sentence, sentence_label in corpus:
    5.         #将句子中的词逐个替换成id，如果句子中的词不在词表内，则替换成oov
    6.         #这里需要注意，一般来说我们可能需要查看一下test-set中，句子oov的比例，
    7.         #如果存在过多oov的情况，那就说明我们的训练数据不足或者切分存在巨大偏差，需要调整
    8.         sentence = [word2id_dict[word] if word in word2id_dict \
    9.                     else word2id_dict['[oov]'] for word in sentence]    
    10.         data_set.append((sentence, sentence_label))
    11.     return data_set
    13. train_corpus = convert_corpus_to_id(train_corpus, word2id_dict)
    14. test_corpus = convert_corpus_to_id(test_corpus, word2id_dict)
    15. print("%d tokens in the corpus" % len(train_corpus))
    16. print(train_corpus[:5])
    17. print(test_corpus[:5])

    1. 定义长短时记忆模型

    使用飞桨定义一个长短时记忆模型，以便情感分析模型调用，代码如下：

    1. import paddle.fluid as fluid
    2. #使用飞桨实现一个长短时记忆模型
    3. class SimpleLSTMRNN(fluid.Layer):
    5.     def __init__(self,
    6.                  hidden_size,
    7.                  num_steps,
    8.                  num_layers=1,
    9.                  init_scale=0.1,
    10.                  dropout=None):
    12.         #这个模型有几个参数：
    13.         #1. hidden_size，表示embedding-size，或者是记忆向量的维度
    14.         #2. num_steps，表示这个长短时记忆网络，最多可以考虑多长的时间序列
    15.         #3. num_layers，表示这个长短时记忆网络内部有多少层，我们知道，
    16.         #   给定一个形状为[batch_size, seq_len, embedding_size]的输入，
    17.         # 长短时记忆网络会输出一个同样为[batch_size, seq_len, embedding_size]的输出，
    18.         #   我们可以把这个输出再链到一个新的长短时记忆网络上
    19.         # 如此叠加多层长短时记忆网络，有助于学习更复杂的句子甚至是篇章。
    20.         #4. init_scale，表示网络内部的参数的初始化范围，
    21.         # 长短时记忆网络内部用了很多tanh，sigmoid等激活函数，这些函数对数值精度非常敏感，
    22.         # 因此我们一般只使用比较小的初始化范围，以保证效果，
    24.         super(SimpleLSTMRNN, self).__init__()
    25.         self._hidden_size = hidden_size
    26.         self._num_layers = num_layers
    27.         self._init_scale = init_scale
    28.         self._dropout = dropout
    29.         self._num_steps = num_steps
    30.         self.cell_array = []
    31.         self.hidden_array = []
    33.         # weight_1_arr用于存储不同层的长短时记忆网络中，不同门的W参数
    34.         self.weight_1_arr = []
    36.         # bias_arr用于存储不同层的长短时记忆网络中，不同门的b参数
    37.         self.bias_arr = []
    38.         self.mask_array = []
    40.         # 通过使用create_parameter函数，创建不同长短时记忆网络层中的参数
    41.         # 通过上面的公式，我们知道，我们总共需要8个形状为[_hidden_size, _hidden_size]的W向量
    42.         # 和4个形状为[_hidden_size]的b向量，因此，我们在声明参数的时候，
    43.         # 一次性声明一个大小为[self._hidden_size * 2, self._hidden_size * 4]的参数
    44.         # 和一个 大小为[self._hidden_size * 4]的参数，这样做的好处是，
    45.         # 可以使用一次矩阵计算，同时计算8个不同的矩阵乘法
    46.         # 以便加快计算速度
    47.         for i in range(self._num_layers):
    48.             weight_1 = self.create_parameter(
    49.                 attr=fluid.ParamAttr(
    50.                     initializer=fluid.initializer.UniformInitializer(
    51.                         low=-self._init_scale, high=self._init_scale)),
    52.                 shape=[self._hidden_size * 2, self._hidden_size * 4],
    53.                 dtype="float32",
    54.                 default_initializer=fluid.initializer.UniformInitializer(
    55.                     low=-self._init_scale, high=self._init_scale))
    56.             self.weight_1_arr.append(self.add_parameter('w_%d' % i, weight_1))
    57.             bias_1 = self.create_parameter(
    58.                 attr=fluid.ParamAttr(
    59.                     initializer=fluid.initializer.UniformInitializer(
    60.                         low=-self._init_scale, high=self._init_scale)),
    61.                 shape=[self._hidden_size * 4],
    62.                 dtype="float32",
    63.                 default_initializer=fluid.initializer.Constant(0.0))
    64.             self.bias_arr.append(self.add_parameter('b_%d' % i, bias_1))
    66.     # 定义LSTM网络的前向计算逻辑，飞桨会自动根据前向计算结果，给出反向结果
    67.     def forward(self, input_embedding, init_hidden=None, init_cell=None):
    68.         self.cell_array = []
    69.         self.hidden_array = []
    71.         #输入有三个信号：
    72.         # 1. input_embedding，这个就是输入句子的embedding表示，
    73.         # 是一个形状为[batch_size, seq_len, embedding_size]的张量
    74.         # 2. init_hidden，这个表示LSTM中每一层的初始h的值，有时候，
    75.         # 我们需要显示地指定这个值，在不需要的时候，就可以把这个值设置为空
    76.         # 3. init_cell，这个表示LSTM中每一层的初始c的值，有时候，
    77.         # 我们需要显示地指定这个值，在不需要的时候，就可以把这个值设置为空
    79.         # 我们需要通过slice操作，把每一层的初始hidden和cell值拿出来，
    80.         # 并存储在cell_array和hidden_array中
    81.         for i in range(self._num_layers):
    82.             pre_hidden = fluid.layers.slice(
    83.                 init_hidden, axes=[0], starts=[i], ends=[i + 1])
    84.             pre_cell = fluid.layers.slice(
    85.                 init_cell, axes=[0], starts=[i], ends=[i + 1])
    86.             pre_hidden = fluid.layers.reshape(
    87.                 pre_hidden, shape=[-1, self._hidden_size])
    88.             pre_cell = fluid.layers.reshape(
    89.                 pre_cell, shape=[-1, self._hidden_size])
    90.             self.hidden_array.append(pre_hidden)
    91.             self.cell_array.append(pre_cell)
    93.         # res记录了LSTM中每一层的输出结果（hidden）
    94.         res = []
    95.         for index in range(self._num_steps):
    96.             # 首先需要通过slice函数，拿到输入tensor input_embedding中当前位置的词的向量表示
    97.             # 并把这个词的向量表示转换为一个大小为 [batch_size, embedding_size]的张量
    98.             self._input = fluid.layers.slice(
    99.                 input_embedding, axes=[1], starts=[index], ends=[index + 1])
    100.             self._input = fluid.layers.reshape(
    101.                 self._input, shape=[-1, self._hidden_size])
    103.             # 计算每一层的结果，从下而上
    104.             for k in range(self._num_layers):
    105.                 # 首先获取每一层LSTM对应上一个时间步的hidden，cell，以及当前层的W和b参数
    106.                 pre_hidden = self.hidden_array[k]
    107.                 pre_cell = self.cell_array[k]
    108.                 weight_1 = self.weight_1_arr[k]
    109.                 bias = self.bias_arr[k]
    111.                 # 我们把hidden和拿到的当前步的input拼接在一起，便于后续计算
    112.                 nn = fluid.layers.concat([self._input, pre_hidden], 1)
    114.                 # 将输入门，遗忘门，输出门等对应的W参数，和输入input和pre-hidden相乘
    115.                 # 我们通过一步计算，就同时完成了8个不同的矩阵运算，提高了运算效率
    116.                 gate_input = fluid.layers.matmul(x=nn, y=weight_1)
    118.                 # 将b参数也加入到前面的运算结果中
    119.                 gate_input = fluid.layers.elementwise_add(gate_input, bias)
    121.                 # 通过split函数，将每个门得到的结果拿出来
    122.                 i, j, f, o = fluid.layers.split(
    123.                     gate_input, num_or_sections=4, dim=-1)
    125.                 # 把输入门，遗忘门，输出门等对应的权重作用在当前输入input和pre-hidden上
    126.                 c = pre_cell * fluid.layers.sigmoid(f) + fluid.layers.sigmoid(
    127.                     i) * fluid.layers.tanh(j)
    128.                 m = fluid.layers.tanh(c) * fluid.layers.sigmoid(o)
    130.                 # 记录当前步骤的计算结果，
    131.                 # m是当前步骤需要输出的hidden
    132.                 # c是当前步骤需要输出的cell
    133.                 self.hidden_array[k] = m
    134.                 self.cell_array[k] = c
    135.                 self._input = m
    137.                 # 一般来说，我们有时候会在LSTM的结果结果内加入dropout操作
    138.                 # 这样会提高模型的训练鲁棒性
    139.                 if self._dropout is not None and self._dropout > 0.0:
    140.                     self._input = fluid.layers.dropout(
    141.                         self._input,
    142.                         dropout_prob=self._dropout,
    143.                         dropout_implementation='upscale_in_train')
    145.             res.append(
    146.                 fluid.layers.reshape(
    147.                     self._input, shape=[1, -1, self._hidden_size]))
    149.         # 计算长短时记忆网络的结果返回回来，包括：
    150.         # 1. real_res：每个时间步上不同层的hidden结果
    151.         # 2. last_hidden：最后一个时间步中，每一层的hidden的结果，
    152.         # 形状为：[batch_size, num_layers, hidden_size]
    153.         # 3. last_cell：最后一个时间步中，每一层的cell的结果，
    154.         # 形状为：[batch_size, num_layers, hidden_size]
    155.         real_res = fluid.layers.concat(res, 0)
    156.         real_res = fluid.layers.transpose(x=real_res, perm=[1, 0, 2])
    157.         last_hidden = fluid.layers.concat(self.hidden_array, 1)
    158.         last_hidden = fluid.layers.reshape(
    159.         last_hidden = fluid.layers.transpose(x=last_hidden, perm=[1, 0, 2])
    160.         last_cell = fluid.layers.concat(self.cell_array, 1)
    161.         last_cell = fluid.layers.reshape(
    163.         last_cell = fluid.layers.transpose(x=last_cell, perm=[1, 0, 2])
    165.         return real_res, last_hidden, last_cell

    2. 定义情感分析模型

    长短时记忆模型定义完成后，我们便可以开始定义一个基于长短时记忆模型的情感分析模型，代码如下：

    2. import paddle.fluid as fluid
    3. # 定义一个可以用于情感分类的网络
    4. class SentimentClassifier(fluid.Layer):
    5.     def __init__(self,
    6.                  hidden_size,
    7.                  vocab_size,
    8.                  class_num=2,
    9.                  num_layers=1,
    10.                  num_steps=128,
    11.                  init_scale=0.1,
    12.                  dropout=None):
    14.         #这个模型的参数分别为：
    15.         #1. hidden_size，表示embedding-size，hidden和cell向量的维度
    16.         #2. vocab_size，模型可以考虑的词表大小
    17.         #3. class_num，情感类型个数，可以是2分类，也可以是多分类
    18.         #4. num_steps，表示这个情感分析模型最大可以考虑的句子长度
    19.         #5. init_scale，表示网络内部的参数的初始化范围，
    20.         # 长短时记忆网络内部用了很多tanh，sigmoid等激活函数，这些函数对数值精度非常敏感，
    21.         # 因此我们一般只使用比较小的初始化范围，以保证效果
    23.         super(SentimentClassifier, self).__init__()
    24.         self.hidden_size = hidden_size
    25.         self.vocab_size = vocab_size
    26.         self.class_num = class_num
    27.         self.init_scale = init_scale
    28.         self.num_layers = num_layers
    29.         self.num_steps = num_steps
    30.         self.dropout = dropout
    32.         # 声明一个LSTM模型，用来把一个句子抽象城一个向量
    33.         self.simple_lstm_rnn = SimpleLSTMRNN(
    34.             hidden_size,
    35.             num_steps,
    36.             num_layers=num_layers,
    37.             init_scale=init_scale,
    38.             dropout=dropout)
    40.         # 声明一个embedding层，用来把句子中的每个词转换为向量
    41.         self.embedding = Embedding(
    42.             size=[vocab_size, hidden_size],
    43.             dtype='float32',
    44.             is_sparse=False,
    45.             param_attr=fluid.ParamAttr(
    46.                 name='embedding_para',
    47.                 initializer=fluid.initializer.UniformInitializer(
    48.                     low=-init_scale, high=init_scale)))
    50.         # 在得到一个句子的向量表示后，我们需要根据这个向量表示对这个句子进行分类
    51.         # 一般来说，我们可以把这个句子的向量表示，
    52.         # 乘以一个大小为[self.hidden_size, self.class_num]的W参数
    53.         # 并加上一个大小为[self.class_num]的b参数
    54.         # 通过这种手段达到把句子向量映射到分类结果的目标
    56.         # 我们需要声明最终在使用句子向量映射到具体情感类别过程中所需要使用的参数
    57.         # 这个参数的大小一般是[self.hidden_size, self.class_num]
    58.         self.softmax_weight = self.create_parameter(
    59.             attr=fluid.ParamAttr(),
    60.             shape=[self.hidden_size, self.class_num],
    61.             dtype="float32",
    62.             default_initializer=fluid.initializer.UniformInitializer(
    63.                 low=-self.init_scale, high=self.init_scale))
    64.         # 同样的，我们需要声明最终分类过程中的b参数
    65.         #  这个参数的大小一般是[self.class_num]
    66.         self.softmax_bias = self.create_parameter(
    67.             attr=fluid.ParamAttr(),
    68.             shape=[self.class_num],
    69.             dtype="float32",
    70.             default_initializer=fluid.initializer.UniformInitializer(
    71.                 low=-self.init_scale, high=self.init_scale))
    73.     def forward(self, input, label):
    75.         # 首先我们需要定义LSTM的初始hidden和cell，这里我们使用0来初始化这个序列的记忆
    76.         init_hidden_data = np.zeros(
    77.             (1, batch_size, embedding_size), dtype='float32')
    78.         init_cell_data = np.zeros(
    79.             (1, batch_size, embedding_size), dtype='float32')
    81.         # 将这些初始记忆转换为飞桨可计算的向量
    82.         # 并设置stop-gradient=True，避免这些向量被更新，从而影响训练效果
    83.         init_hidden = fluid.dygraph.to_variable(init_hidden_data)
    84.         init_hidden.stop_gradient = True
    85.         init_cell = fluid.dygraph.to_variable(init_cell_data)
    86.         init_cell.stop_gradient = True
    88.         init_h = fluid.layers.reshape(
    89.             init_hidden, shape=[self.num_layers, -1, self.hidden_size])
    91.         init_c = fluid.layers.reshape(
    92.             init_cell, shape=[self.num_layers, -1, self.hidden_size])
    94.         # 将输入的句子的mini-batch input，转换为词向量表示
    95.         x_emb = self.embedding(input)
    97.         x_emb = fluid.layers.reshape(
    98.             x_emb, shape=[-1, self.num_steps, self.hidden_size])
    99.         if self.dropout is not None and self.dropout > 0.0:
    100.             x_emb = fluid.layers.dropout(
    101.                 x_emb,
    102.                 dropout_prob=self.dropout,
    103.                 dropout_implementation='upscale_in_train')
    105.         # 使用LSTM网络，把每个句子转换为向量表示
    106.         rnn_out, last_hidden, last_cell = self.simple_lstm_rnn(x_emb, init_h,
    107.                                                                init_c)
    108.         last_hidden = fluid.layers.reshape(
    109.             last_hidden, shape=[-1, self.hidden_size])
    111.         # 将每个句子的向量表示，通过矩阵计算，映射到具体的情感类别上
    112.         projection = fluid.layers.matmul(last_hidden, self.softmax_weight)
    113.         projection = fluid.layers.elementwise_add(projection, self.softmax_bias)
    114.         projection = fluid.layers.reshape(
    115.             projection, shape=[-1, self.class_num])
    116.         pred = fluid.layers.softmax(projection, axis=-1)
    118.         # 根据给定的标签信息，计算整个网络的损失函数，这里我们可以直接使用分类任务中常使用的交叉熵来训练网络
    119.         loss = fluid.layers.softmax_with_cross_entropy(
    120.             logits=projection, label=label, soft_label=False)
    121.         loss = fluid.layers.reduce_mean(loss)
    123.         # 最终返回预测结果pred，和网络的loss

    模型训练