devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用LSTM完成情感分析任务_lstm 情感分析训练loss公式

作者：小丑西瓜9 | 2024-06-18 06:50:36

赞

踩

lstm 情感分析训练loss公式

内容都是百度AIstudio的内容，我只是在这里做个笔记，不是原创。

 

 借助长短时记忆网络，我们可以非常轻松地完成情感分析任务。如 图8 所示。对于每个句子，我们首先通过截断和填充的方式，把这些句子变成固定长度的向量。然后，利用长短时记忆网络，从左到右开始阅读每个句子。在完成阅读之后，我们使用长短时记忆网络的最后一个输出记忆，作为整个句子的语义信息，并直接把这个向量作为输入，送入一个分类层进行分类，从而完成对情感分析问题的神经网络建模。

 

 

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

接下来让我们看看如何使用飞桨实现一个基于长短时记忆网络的情感分析模型。在飞桨中，不同深度学习模型的训练过程基本一致，流程如下：

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

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

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

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

  1. #encoding=utf8
  2. #   Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
  3. #
  4. # Licensed under the Apache License, Version 2.0 (the "License");
  5. # you may not use this file except in compliance with the License.
  6. # You may obtain a copy of the License at
  7. #
  8. #     http://www.apache.org/licenses/LICENSE-2.0
  9. #
  10. # Unless required by applicable law or agreed to in writing, software
  11. # distributed under the License is distributed on an "AS IS" BASIS,
  12. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. # See the License for the specific language governing permissions and
  14. # limitations under the License.
  15.  
  16. import io
  17. import os
  18. import re
  19. import sys
  20. import six
  21. import requests
  22. import string
  23. import tarfile
  24. import hashlib
  25. from collections import OrderedDict 
  26. import math
  27. import random
  28. import numpy as np
  29. import paddle
  30. import paddle.fluid as fluid
  31.  
  32. from paddle.fluid.dygraph.nn import Embedding
  33.  
  34.  
  35. def download():
  36.     #通过python的requests类，下载存储在
  37.     #https://dataset.bj.bcebos.com/imdb%2FaclImdb_v1.tar.gz的文件
  38.     corpus_url = "https://dataset.bj.bcebos.com/imdb%2FaclImdb_v1.tar.gz"
  39.     web_request = requests.get(corpus_url)
  40.     corpus = web_request.content
  41.     print("hello:",corpus)
  42.  
  43.     #将下载的文件写在当前目录的aclImdb_v1.tar.gz文件内
  44.     with open("./aclImdb_v1.tar.gz", "wb") as f:
  45.         f.write(corpus)
  46.     f.close()
  47.  
  48. download()
  49.  
  50. def load_imdb(is_training):
  51.     data_set = []
  52.  
  53.     #aclImdb_v1.tar.gz解压后是一个目录
  54.     #我们可以使用python的rarfile库进行解压
  55.     #训练数据和测试数据已经经过切分，其中训练数据的地址为：
  56.     #./aclImdb/train/pos/ 和 ./aclImdb/train/neg/，分别存储着正向情感的数据和负向情感的数据
  57.     #我们把数据依次读取出来，并放到data_set里
  58.     #data_set中每个元素都是一个二元组，（句子，label），其中label=0表示负向情感，label=1表示正向情感
  59.     
  60.     for label in ["pos", "neg"]:
  61.         with tarfile.open("./aclImdb_v1.tar.gz") as tarf:
  62.             path_pattern = "aclImdb/train/" + label + "/.*\.txt$" if is_training \
  63.                 else "aclImdb/test/" + label + "/.*\.txt$"
  64.             path_pattern = re.compile(path_pattern)
  65.             tf = tarf.next()
  66.             while tf != None:
  67.                 if bool(path_pattern.match(tf.name)):
  68.                     sentence = tarf.extractfile(tf).read().decode()
  69.                     sentence_label = 0 if label == 'neg' else 1
  70.                     data_set.append((sentence, sentence_label)) 
  71.                 tf = tarf.next()
  72.  
  73.     return data_set
  74.  
  75. train_corpus = load_imdb(True)
  76. test_corpus = load_imdb(False)
  77.  
  78. for i in range(6):
  79.     print("sentence %d, %s" % (i, train_corpus[i][0]))    
  80.     print("sentence %d, label %d" % (i, train_corpus[i][1]))
  81.  
  82. def data_preprocess(corpus):
  83.     data_set = []
  84.     for sentence, sentence_label in corpus:
  85.         #这里有一个小trick是把所有的句子转换为小写，从而减小词表的大小
  86.         #一般来说这样的做法有助于效果提升
  87.         sentence = sentence.strip().lower()
  88.         sentence = sentence.split(" ")
  89.         
  90.         data_set.append((sentence, sentence_label))
  91.  
  92.     return data_set
  93.  
  94. train_corpus = data_preprocess(train_corpus)
  95. test_corpus = data_preprocess(test_corpus)
  96. print(train_corpus[:2])
  97.  
  98. #构造词典，统计每个词的频率，并根据频率将每个词转换为一个整数id
  99. def build_dict(corpus):
  100.     word_freq_dict = dict()
  101.     for sentence, _ in corpus:
  102.         for word in sentence:
  103.             if word not in word_freq_dict:
  104.                 word_freq_dict[word] = 0
  105.             word_freq_dict[word] += 1
  106.  
  107.     word_freq_dict = sorted(word_freq_dict.items(), key = lambda x:x[1], reverse = True)
  108.     
  109.     word2id_dict = dict()
  110.     word2id_freq = dict()
  111.  
  112.     #一般来说，我们把oov和pad放在词典前面，给他们一个比较小的id，这样比较方便记忆，并且易于后续扩展词表
  113.     word2id_dict['[oov]'] = 0
  114.     word2id_freq[0] = 1e10
  115.  
  116.     word2id_dict['[pad]'] = 1
  117.     word2id_freq[1] = 1e10
  118.  
  119.     for word, freq in word_freq_dict:
  120.         word2id_dict[word] = len(word2id_dict)
  121.         word2id_freq[word2id_dict[word]] = freq
  122.  
  123.     return word2id_freq, word2id_dict
  124.  
  125. word2id_freq, word2id_dict = build_dict(train_corpus)
  126. vocab_size = len(word2id_freq)
  127. print("there are totoally %d different words in the corpus" % vocab_size)
  128. for _, (word, word_id) in zip(range(50), word2id_dict.items()):
  129.     print("word %s, its id %d, its word freq %d" % (word, word_id, word2id_freq[word_id]))
  130.  
  131. #把语料转换为id序列
  132. def convert_corpus_to_id(corpus, word2id_dict):
  133.     data_set = []
  134.     for sentence, sentence_label in corpus:
  135.         #将句子中的词逐个替换成id，如果句子中的词不在词表内，则替换成oov
  136.         #这里需要注意，一般来说我们可能需要查看一下test-set中，句子oov的比例，
  137.         #如果存在过多oov的情况，那就说明我们的训练数据不足或者切分存在巨大偏差，需要调整
  138.         sentence = [word2id_dict[word] if word in word2id_dict \
  139.                     else word2id_dict['[oov]'] for word in sentence]    
  140.         data_set.append((sentence, sentence_label))
  141.     return data_set
  142.  
  143. train_corpus = convert_corpus_to_id(train_corpus, word2id_dict)
  144. test_corpus = convert_corpus_to_id(test_corpus, word2id_dict)
  145. print("%d tokens in the corpus" % len(train_corpus))
  146. print(train_corpus[:5])
  147. print(test_corpus[:5])
  148.  
  149. #编写一个迭代器，每次调用这个迭代器都会返回一个新的batch，用于训练或者预测
  150. def build_batch(word2id_dict, corpus, batch_size, epoch_num, max_seq_len, shuffle = True):
  151.  
  152.     #模型将会接受的两个输入：
  153.     # 1. 一个形状为[batch_size, max_seq_len]的张量，sentence_batch，代表了一个mini-batch的句子。
  154.     # 2. 一个形状为[batch_size, 1]的张量，sentence_label_batch，
  155.     #    每个元素都是非0即1，代表了每个句子的情感类别（正向或者负向）
  156.     sentence_batch = []
  157.     sentence_label_batch = []
  158.  
  159.     for _ in range(epoch_num): 
  160.  
  161.         #每个epcoh前都shuffle一下数据，有助于提高模型训练的效果
  162.         #但是对于预测任务，不要做数据shuffle
  163.         if shuffle:
  164.             random.shuffle(corpus)
  165.  
  166.         for sentence, sentence_label in corpus:
  167.             sentence_sample = sentence[:min(max_seq_len, len(sentence))]
  168.             if len(sentence_sample) < max_seq_len:
  169.                 for _ in range(max_seq_len - len(sentence_sample)):
  170.                     sentence_sample.append(word2id_dict['[pad]'])
  171.             
  172.             
  173.             sentence_sample = [[word_id] for word_id in sentence_sample]
  174.  
  175.             sentence_batch.append(sentence_sample)
  176.             sentence_label_batch.append([sentence_label])
  177.  
  178.             if len(sentence_batch) == batch_size:
  179.                 yield np.array(sentence_batch).astype("int64"), np.array(sentence_label_batch).astype("int64")
  180.                 sentence_batch = []
  181.                 sentence_label_batch = []
  182.  
  183.     if len(sentence_batch) == batch_size:
  184.         yield np.array(sentence_batch).astype("int64"), np.array(sentence_label_batch).astype("int64")
  185.  
  186. for _, batch in zip(range(10), build_batch(word2id_dict,train_corpus, batch_size=3, epoch_num=3, max_seq_len=30)):
  187.     print(batch)
  1. import paddle.fluid as fluid
  2. #使用飞桨实现一个长短时记忆模型
  3. class SimpleLSTMRNN(fluid.Layer):
  4.     
  5.     def __init__(self,
  6.                  hidden_size,
  7.                  num_steps,
  8.                  num_layers=1,
  9.                  init_scale=0.1,
  10.                  dropout=None):
  11.         
  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.         # 因此我们一般只使用比较小的初始化范围，以保证效果，
  23.         
  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._input = None
  30.         self._num_steps = num_steps
  31.         self.cell_array = []
  32.         self.hidden_array = []
  33.  
  34.         # weight_1_arr用于存储不同层的长短时记忆网络中，不同门的W参数
  35.         self.weight_1_arr = []
  36.         self.weight_2_arr = []
  37.         # bias_arr用于存储不同层的长短时记忆网络中，不同门的b参数
  38.         self.bias_arr = []
  39.         self.mask_array = []
  40.  
  41.         # 通过使用create_parameter函数，创建不同长短时记忆网络层中的参数
  42.         # 通过上面的公式，我们知道，我们总共需要8个形状为[_hidden_size, _hidden_size]的W向量
  43.         # 和4个形状为[_hidden_size]的b向量，因此，我们在声明参数的时候，
  44.         # 一次性声明一个大小为[self._hidden_size * 2, self._hidden_size * 4]的参数
  45.         # 和一个 大小为[self._hidden_size * 4]的参数，这样做的好处是，
  46.         # 可以使用一次矩阵计算，同时计算8个不同的矩阵乘法
  47.         # 以便加快计算速度
  48.         for i in range(self._num_layers):
  49.             weight_1 = self.create_parameter(
  50.                 attr=fluid.ParamAttr(
  51.                     initializer=fluid.initializer.UniformInitializer(
  52.                         low=-self._init_scale, high=self._init_scale)),
  53.                 shape=[self._hidden_size * 2, self._hidden_size * 4],
  54.                 dtype="float32",
  55.                 default_initializer=fluid.initializer.UniformInitializer(
  56.                     low=-self._init_scale, high=self._init_scale))
  57.             self.weight_1_arr.append(self.add_parameter('w_%d' % i, weight_1))
  58.             bias_1 = self.create_parameter(
  59.                 attr=fluid.ParamAttr(
  60.                     initializer=fluid.initializer.UniformInitializer(
  61.                         low=-self._init_scale, high=self._init_scale)),
  62.                 shape=[self._hidden_size * 4],
  63.                 dtype="float32",
  64.                 default_initializer=fluid.initializer.Constant(0.0))
  65.             self.bias_arr.append(self.add_parameter('b_%d' % i, bias_1))
  66.  
  67.     # 定义LSTM网络的前向计算逻辑，飞桨会自动根据前向计算结果，给出反向结果
  68.     def forward(self, input_embedding, init_hidden=None, init_cell=None):
  69.         self.cell_array = []
  70.         self.hidden_array = []
  71.         
  72.         #输入有三个信号：
  73.         # 1. input_embedding，这个就是输入句子的embedding表示，
  74.         # 是一个形状为[batch_size, seq_len, embedding_size]的张量
  75.         # 2. init_hidden，这个表示LSTM中每一层的初始h的值，有时候，
  76.         # 我们需要显示地指定这个值，在不需要的时候，就可以把这个值设置为空
  77.         # 3. init_cell，这个表示LSTM中每一层的初始c的值，有时候，
  78.         # 我们需要显示地指定这个值，在不需要的时候，就可以把这个值设置为空
  79.  
  80.         # 我们需要通过slice操作，把每一层的初始hidden和cell值拿出来，
  81.         # 并存储在cell_array和hidden_array中
  82.         for i in range(self._num_layers):
  83.             pre_hidden = fluid.layers.slice(
  84.                 init_hidden, axes=[0], starts=[i], ends=[i + 1])
  85.             pre_cell = fluid.layers.slice(
  86.                 init_cell, axes=[0], starts=[i], ends=[i + 1])
  87.             pre_hidden = fluid.layers.reshape(
  88.                 pre_hidden, shape=[-1, self._hidden_size])
  89.             pre_cell = fluid.layers.reshape(
  90.                 pre_cell, shape=[-1, self._hidden_size])
  91.             self.hidden_array.append(pre_hidden)
  92.             self.cell_array.append(pre_cell)
  93.  
  94.         # res记录了LSTM中每一层的输出结果（hidden）
  95.         res = []
  96.         for index in range(self._num_steps):
  97.             # 首先需要通过slice函数，拿到输入tensor input_embedding中当前位置的词的向量表示
  98.             # 并把这个词的向量表示转换为一个大小为 [batch_size, embedding_size]的张量
  99.             self._input = fluid.layers.slice(
  100.                 input_embedding, axes=[1], starts=[index], ends=[index + 1])
  101.             self._input = fluid.layers.reshape(
  102.                 self._input, shape=[-1, self._hidden_size])
  103.             
  104.             # 计算每一层的结果，从下而上
  105.             for k in range(self._num_layers):
  106.                 # 首先获取每一层LSTM对应上一个时间步的hidden，cell，以及当前层的W和b参数
  107.                 pre_hidden = self.hidden_array[k]
  108.                 pre_cell = self.cell_array[k]
  109.                 weight_1 = self.weight_1_arr[k]
  110.                 bias = self.bias_arr[k]
  111.  
  112.                 # 我们把hidden和拿到的当前步的input拼接在一起，便于后续计算
  113.                 nn = fluid.layers.concat([self._input, pre_hidden], 1)
  114.                 
  115.                 # 将输入门，遗忘门，输出门等对应的W参数，和输入input和pre-hidden相乘
  116.                 # 我们通过一步计算，就同时完成了8个不同的矩阵运算，提高了运算效率
  117.                 gate_input = fluid.layers.matmul(x=nn, y=weight_1)
  118.  
  119.                 # 将b参数也加入到前面的运算结果中
  120.                 gate_input = fluid.layers.elementwise_add(gate_input, bias)
  121.                 
  122.                 # 通过split函数，将每个门得到的结果拿出来
  123.                 i, j, f, o = fluid.layers.split(
  124.                     gate_input, num_or_sections=4, dim=-1)
  125.                 
  126.                 # 把输入门，遗忘门，输出门等对应的权重作用在当前输入input和pre-hidden上
  127.                 c = pre_cell * fluid.layers.sigmoid(f) + fluid.layers.sigmoid(
  128.                     i) * fluid.layers.tanh(j)
  129.                 m = fluid.layers.tanh(c) * fluid.layers.sigmoid(o)
  130.                 
  131.                 # 记录当前步骤的计算结果，
  132.                 # m是当前步骤需要输出的hidden
  133.                 # c是当前步骤需要输出的cell
  134.                 self.hidden_array[k] = m
  135.                 self.cell_array[k] = c
  136.                 self._input = m
  137.                 
  138.                 # 一般来说，我们有时候会在LSTM的结果结果内加入dropout操作
  139.                 # 这样会提高模型的训练鲁棒性
  140.                 if self._dropout is not None and self._dropout > 0.0:
  141.                     self._input = fluid.layers.dropout(
  142.                         self._input,
  143.                         dropout_prob=self._dropout,
  144.                         dropout_implementation='upscale_in_train')
  145.                     
  146.             res.append(
  147.                 fluid.layers.reshape(
  148.                     self._input, shape=[1, -1, self._hidden_size]))
  149.         
  150.         # 计算长短时记忆网络的结果返回回来，包括：
  151.         # 1. real_res：每个时间步上不同层的hidden结果
  152.         # 2. last_hidden：最后一个时间步中，每一层的hidden的结果，
  153.         # 形状为：[batch_size, num_layers, hidden_size]
  154.         # 3. last_cell：最后一个时间步中，每一层的cell的结果，
  155.         # 形状为：[batch_size, num_layers, hidden_size]
  156.         real_res = fluid.layers.concat(res, 0)
  157.         real_res = fluid.layers.transpose(x=real_res, perm=[1, 0, 2])
  158.         last_hidden = fluid.layers.concat(self.hidden_array, 1)
  159.         last_hidden = fluid.layers.reshape(
  160.             last_hidden, shape=[-1, self._num_layers, self._hidden_size])
  161.         last_hidden = fluid.layers.transpose(x=last_hidden, perm=[1, 0, 2])
  162.         last_cell = fluid.layers.concat(self.cell_array, 1)
  163.         last_cell = fluid.layers.reshape(
  164.             last_cell, shape=[-1, self._num_layers, self._hidden_size])
  165.         last_cell = fluid.layers.transpose(x=last_cell, perm=[1, 0, 2])
  166.         
  167.         return real_res, last_hidden, last_cell
  1.  
  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):
  13.         
  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.         # 因此我们一般只使用比较小的初始化范围，以保证效果
  22.         
  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
  31.  
  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)
  39.         
  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)))
  49.         
  50.         # 在得到一个句子的向量表示后，我们需要根据这个向量表示对这个句子进行分类
  51.         # 一般来说，我们可以把这个句子的向量表示，
  52.         # 乘以一个大小为[self.hidden_size, self.class_num]的W参数
  53.         # 并加上一个大小为[self.class_num]的b参数
  54.         # 通过这种手段达到把句子向量映射到分类结果的目标
  55.         
  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))
  72.  
  73.     def forward(self, input, label):
  74.  
  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')
  80.  
  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
  87.  
  88.         init_h = fluid.layers.reshape(
  89.             init_hidden, shape=[self.num_layers, -1, self.hidden_size])
  90.  
  91.         init_c = fluid.layers.reshape(
  92.             init_cell, shape=[self.num_layers, -1, self.hidden_size])
  93.  
  94.         # 将输入的句子的mini-batch input，转换为词向量表示
  95.         x_emb = self.embedding(input)
  96.  
  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')
  104.         
  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])
  110.         
  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)
  117.         
  118.         # 根据给定的标签信息，计算整个网络的损失函数，这里我们可以直接使用分类任务中常使用的交叉熵来训练网络
  119.         loss = fluid.layers.softmax_with_cross_entropy(
  120.             logits=projection, label=label, soft_label=False)
  121.         loss = fluid.layers.reduce_mean(loss)
  122.  
  123.         # 最终返回预测结果pred，和网络的loss
  124.         return pred, loss
  1. import paddle.fluid as fluid
  2. #开始训练
  3. batch_size = 128
  4. epoch_num = 5
  5. embedding_size = 256
  6. step = 0
  7. learning_rate = 0.01
  8. max_seq_len = 128
  9.  
  10. use_gpu=False
  11. place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
  12. with fluid.dygraph.guard(place):
  13.     # 创建一个用于情感分类的网络实例，sentiment_classifier
  14.     sentiment_classifier = SentimentClassifier(
  15.     	embedding_size, vocab_size, num_steps=max_seq_len)
  16.     # 创建优化器AdamOptimizer，用于更新这个网络的参数
  17.     adam = fluid.optimizer.AdamOptimizer(learning_rate=learning_rate, parameter_list = sentiment_classifier.parameters())
  18.  
  19.     for sentences, labels in build_batch(
  20.         word2id_dict, train_corpus, batch_size, epoch_num, max_seq_len):
  21.         
  22.         sentences_var = fluid.dygraph.to_variable(sentences)
  23.         labels_var = fluid.dygraph.to_variable(labels)
  24.         pred, loss = sentiment_classifier(sentences_var, labels_var)
  25.  
  26.         loss.backward()
  27.         adam.minimize(loss)
  28.         sentiment_classifier.clear_gradients()
  29.         
  30.         step += 1
  31.         if step % 10 == 0:
  32.             print("step %d, loss %.3f" % (step, loss.numpy()[0]))
  33.             
  34.     # 我们希望在网络训练结束以后评估一下训练好的网络的效果
  35.     # 通过eval()函数，将网络设置为eval模式，在eval模式中，网络不会进行梯度更新
  36.     sentiment_classifier.eval()
  37.     # 这里我们需要记录模型预测结果的准确率
  38.     # 对于二分类任务来说，准确率的计算公式为：
  39.     # (true_positive + true_negative) / 
  40.     # (true_positive + true_negative + false_positive + false_negative)
  41.     tp = 0.
  42.     tn = 0.
  43.     fp = 0.
  44.     fn = 0.
  45.     for sentences, labels in build_batch(
  46.         word2id_dict, test_corpus, batch_size, 1, max_seq_len):
  47.         
  48.         sentences_var = fluid.dygraph.to_variable(sentences)
  49.         labels_var = fluid.dygraph.to_variable(labels)
  50.         
  51.         # 获取模型对当前batch的输出结果
  52.         pred, loss = sentiment_classifier(sentences_var, labels_var)
  53.  
  54.         # 把输出结果转换为numpy array的数据结构
  55.         # 遍历这个数据结构，比较预测结果和对应label之间的关系，并更新tp，tn，fp和fn
  56.         pred = pred.numpy()
  57.         for i in range(len(pred)):
  58.             if labels[i][0] == 1:
  59.                 if pred[i][1] > pred[i][0]:
  60.                     tp += 1
  61.                 else:
  62.                     fn += 1
  63.             else:
  64.                 if pred[i][1] > pred[i][0]:
  65.                     fp += 1
  66.                 else:
  67.                     tn += 1
  68.  
  69.     # 输出最终评估的模型效果
  70.     print("the acc in the test set is %.3f" % ((tp + tn) / (tp + tn + fp + fn)))

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/734087
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号