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

【深度学习】LSTM实现情感分析 （Pytorch）_lstm pytorch实现 情感分析

作者：小蓝xlanll | 2024-03-31 14:52:38

赞

踩

lstm pytorch实现 情感分析

写在前面：

    pycharm内存问题没有解决，以下代码均在jupyter notebook实现

    像batch_size， 数据条数，循环次数， print_every一类的参数，可以修改尝试，为了解决memoryerror一类的问题，修改过多次。

思路要点：

  • 数据处理，要进行分词，做出映射词典  NLTK 自然语言处理
  • 词向量 embedding 
  • lstm
  • 全连接层
  • dropout 层
  • 分类

处理数据

重点：

  • 解压bz2压缩文件
  1. import bz2
  2. train_file = bz2.BZ2File('data/train.ft.txt.bz2')
  3. test_file = bz2.BZ2File('data/test.ft.txt.bz2')
  • 文件中二进制存储，由输出中 b''看出
b'__label__2 Stuning even for the non-gamer: This sound track was beautiful! It paints the senery in your mind so well I would recomend it even to people who hate vid. game music! I have played the game Chrono Cross but out of all of the games I have ever played it has the best music! It backs away from crude keyboarding and takes a fresher step with grate guitars and soulful orchestras. It would impress anyone who cares to listen! ^_^\n'
  • decode成'utf-8'
  1. train_file = [x.decode('utf-8') for x in train_file[:train_num]]
  2. test_file = [x.decode('utf-8') for x in test_file[:test_num]]

 由尝试输出的train_file中看出，数据集的标签和数据是在一起的，label_1为态度差，设为1， label_2 为态度好，设为2

for i, sen in enumerate(train_data)

解释  i  

  1. #分词
  2. words = Counter()
  3. for i, sen in enumerate(train_data):
  4.     # print(i)
  5.     words_ = nltk.word_tokenize(sen)
  6.     words.update(words_)#更新词频列表

当调用 `Counter` 对象的 `update` 方法时，它会接受一个可迭代对象作为参数，然后将这个可迭代对象中的元素作为键，以及对应元素出现的次数作为值，更新到 `Counter` 对象中。

在上面的代码中，传递给 `update` 方法的参数 `words_` 是一个单词列表，遍历该列表，将每个单词添加到 `Counter` 对象 `words` 中，并且每次出现一个单词，对应的计数值会增加1。

_PAD：表示填充，因为后续会固定所有句子长度。过长的句子进行阶段，过短的句子使用该单词进行填充

re.sub 正则表达式：

  1. '\d’是一个常见的正则表达式，它代表匹配任意一个数字字符（0-9）。在正则表达式中，反斜杠（\）通常用来表示特殊字符的转义，而 \d 表示匹配数字字符
  2. r"([^ ]+(?<=\.[a-z]{3}))"：用于匹配一个空格前面是一个点号和三个小写字母的字符
  •   ([^ ]：这是一个字符集合，匹配除了空格以外的任意字符。
  • ?<=\.[a-z]{3}))：这是一个正向断言，表示匹配前面的模式之后满足括号内条件的内容。具体来说：
  • (?<=   ：开启一个正向断言。
  • \.    :匹配一个点号。
  • [a-z]{3} ：匹配三个连续的小写字母。
  • )    ：结束正向断言。

注意：

为了方便构建模型，需要固定所有句子的长度，自定义句子的固定长度，对于长度不够的句子，在前面填充0(_PAD)，超出长度的句子进行从后面截断

代码： 

  1. import nltk
  2. from collections import Counter
  3. import numpy as np
  4. import bz2
  5.  
  6. #处理数据
  7. train_file = bz2.BZ2File('data/train.ft.txt.bz2')
  8. test_file = bz2.BZ2File('data/test.ft.txt.bz2')
  9. train_file = train_file.readlines()
  10. test_file = test_file.readlines()
  11. print(train_file[0])
  12.  
  13. #8:2划分数据集
  14. train_num = 8000
  15. test_num = 2000
  16.  
  17. train_file = [x.decode('utf-8') for x in train_file[:train_num]]
  18. test_file = [x.decode('utf-8') for x in test_file[:test_num]]
  19.  
  20. # print(train_file[0])
  21. #差 0 好 1
  22. #去掉 \n [:-1]
  23. train_labels = [0 if x.split(' ')[0] == '__label__1' else 1 for x in train_file]
  24. train_data = [x.split(' ', 1)[1][: -1].lower() for x in train_file]
  25.  
  26. test_labels = [0 if x.split(' ')[0] == '__label__1' else 1 for x in test_file]
  27. test_data = [x.split(' ', 1)[1][: -1].lower() for x in test_file]
  28.  
  29. #sub 正则表达式
  30. for i in range(len(train_data)):
  31.     train_data[i] = re.sub('\d','0',train_data[i])
  32.  
  33. for i in range(len(test_data)):
  34.     test_data[i] = re.sub('\d','0',test_data[i])
  35.  
  36. for i in range(len(train_data)):
  37.     if 'www.' in train_data[i] or 'http:' in train_data[i] or 'https:' in train_data[i] or '.com' in train_data[i]:
  38.         train_data[i] = re.sub(r"([^ ]+(?<=\.[a-z]{3}))", "<url>", train_data[i])
  39.         
  40. for i in range(len(test_data)):
  41.     if 'www.' in test_data[i] or 'http:' in test_data[i] or 'https:' in test_data[i] or '.com' in test_data[i]:
  42.         test_data[i] = re.sub(r"([^ ]+(?<=\.[a-z]{3}))", "<url>", test_data[i])
  43.  
  44. #! 映射词典
  45. #分词
  46. words = Counter()
  47. for i, sen in enumerate(train_data):
  48.     # print(i)
  49.     words_ = nltk.word_tokenize(sen)
  50.     words.update(words_)#更新词频列表
  51.     train_data[i] = words_
  52.  
  53. print("100% done")
  54.  
  55. # words 从大到小排列顺序
  56. words = sorted(words, key=words.get, reverse=True)
  57. words = ['_PAD'] + words
  58.  
  59. #对单词进行编码，将单词映射为数字，（单词所对应索引下标）
  60. word2idx = {x: i for i, x in enumerate(words)}
  61. idx2word = {i: o for i, o in enumerate(words)}
  62.  
  63. #将train_data, test_data中的单词转为数字
  64. for i, sen in enumerate(train_data):
  65.     train_data[i] = [word2idx[word] if word in word2idx else 0 for word in sen]
  66. for i, sen in enumerate(test_data):
  67.     test_data[i] = [word2idx[word.lower()] if word.lower() in word2idx else 0 for word in nltk.word_tokenize(sen)]
  68.  
  69. #固定长度
  70. def pad_input(sentences, seq_len):
  71.     features = np.zeros((len(sentences), seq_len),dtype=int)
  72.     for ii, review in enumerate(sentences):
  73.         if len(review) != 0:
  74.             features[ii, -len(review):] = np.array(review)[:seq_len]
  75.     return features
  76.  
  77. # 固定测试数据集和训练数据集的句子长度
  78. train_data = pad_input(train_data, 200)
  79. test_data = pad_input(test_data, 200)
  80.  
  81. train_labels = np.array(train_labels)
  82. test_labels = np.array(test_labels)

构建LSTM模型

重头戏

from torch.utils.data import TensorDataset, DataLoader

这段代码导入了PyTorch库中的`TensorDataset`和`DataLoader`模块。这两个模块提供了对数据集的封装和加载，用于在训练和测试神经网络模型时方便地处理数据。

  • TensorDataset是一个用于创建张量数据集的类，通常用于将特征张量和标签张量组合在一起
  • DataLoader是一个用于加载数据集的类。它提供了对数据集的迭代和批处理的支持
  1. x_data = TensorDataset(torch.from_numpy(train_data), torch.from_numpy(train_labels))
  2. y_data = TensorDataset(torch.from_numpy(test_data), torch.from_numpy(test_labels))

 通过torch.from_numpy将他们转换成pytorch张量，train_data是用于训练的特征张良，train_labels 是相应的标签向量。

  1. train_loader = DataLoader(x_data, shuffle=True, batch_size=batch_size)
  2. test_loader = DataLoader(y_data, shuffle=True, batch_size=batch_size)

`shuffle=True`表示在每个epoch开始时，数据加载器会对数据进行洗牌，以增加模型的泛化能力。`batch_size`参数指定了每个批次中的样本数量。通过调整`batch_size`的大小，可以在训练时有效利用显存，提高模型训练的速度。
`DataLoader`对象可以迭代地返回每个批次的数据。

显卡计算:

device = torch.device('cuda') if torch.cuda.is_available() else torch.device("cpu")

代码：

  1. class SensationNet(nn.Module):
  2.     def __init__(self, vocab_size):
  3.         super(SensationNet, self).__init__()
  4.         embedding_dim = embedding_dim  = 200 #词向量维度
  5.         self.hidden_dim=hidden_dim = 128  #隐藏层神经元  LSTM输出的隐状态
  6.         self.num_layers = num_layers = 2  #隐藏层层数
  7.         dropout_keep_prob = 0.8 #dropout保存比例
  8.  
  9.         #定义embedding，数字 词向量，将单词索引转化成对应的词向量
  10.         self.embedding = nn.Embedding(vocab_size, embedding_dim)
  11.  
  12.         #lstm 层
  13.         self.lstm = nn.LSTM(embedding_dim,
  14.                             hidden_dim,
  15.                             num_layers,
  16.                             dropout=dropout_keep_prob,
  17.                             batch_first=True)
  18.  
  19.         #全连接层
  20.         self.fc = nn.Linear(in_features=hidden_dim, out_features=1)
  21.  
  22.         #激活函数 sigmoid
  23.         self.sigmoid = nn.Sigmoid()
  24.         self.dropout = nn.Dropout(dropout_keep_prob)
  25.  
  26.     #前向传播函数
  27.     def forward(self, x, hidden):
  28.         batch_size = x.size(0)
  29.  
  30.         x = x.long()
  31.         #(, , hidden_dim)
  32.         embeds = self.embedding(x)#编码后的词向量
  33.         # hidden  上一时刻隐状态
  34.         lstm_out, hidden = self.lstm(embeds, hidden)
  35.         #hidden 包含隐状态、细胞状态，两者维度都是(num_layers, batch_size, hidden_dim)
  36.         #lstm_out(batch_size, 词长度, hidden_dim)
  37.  
  38.         #为了进入全连接层，三层张量->二层
  39.         lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)
  40.         out = self.dropout(lstm_out)
  41.         out = self.fc(out)
  42.         out =self.sigmoid(out)#一维
  43.         #一维张量->二维张量，即每个单词都对应一个输出
  44.         out = out.view(batch_size, -1)
  45.         #只关注最后一个时间步的输出即最后一个单词的输出
  46.         out = out[:, -1]
  47.  
  48.         return out, hidden
  49.     """
  50.     初始化隐状态，第一次送入LSTM没有隐状态，所以要初始化，一般全部赋值为0，
  51.      这里之所以是tuple，是因为LSTM需要接受两个隐状态hidden state和cell state
  52.     """
  53.     def init_hidden(self, batch_size):
  54.         hidden = (torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(device),
  55.                   torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(device)
  56.              )
  57.         return hidden

评估：

model.eval()

  • 是 PyTorch 中用于将模型设置为评估模式的方法。在评估模式下，模型的行为会发生变化，例如关闭 Dropout 和 Batch Normalization 的随机性，以确保稳定的输出。

squeeze()

  • 删除单维度条目 

代码：

  1. #评估
  2. test_losses = []
  3. num_correct = 0#正确预测数量
  4. h_f = model.init_hidden(batch_size)#初始化
  5. model.eval()
  6.  
  7. for inputs, labels in test_loader:
  8.     h_f = tuple([e.data for e in h_f])
  9.     inputs, labels = inputs.to(device), labels.to(device)
  10.     output, h_f = model(inputs, h_f)
  11. #     print(output)
  12.     
  13.     #为什么要加squeeze(), 上面那个没加
  14.     test_loss = criterion(output.squeeze(), labels.float())
  15.     test_losses.append(test_loss.item())
  16.     pred = torch.round(output.squeeze())
  17.     correct_tensor = pred.eq(labels.float().view_as(pred))
  18.     correct = np.squeeze(correct_tensor.cpu().numpy())
  19.     num_correct += np.sum(correct)
  20.     
  21. print("Test loss: {:.3f}".format(np.mean(test_losses)))
  22. test_acc = num_correct/len(test_loader.dataset)
  23. print("Test accuracy: {:.3f}%".format(test_acc*100))

问题：

设定基础参数时，对比rnn模型，有一个疑问：LSTM模型也需要设定隐藏层的层数和神经元数量吗？

chatgpt：是的，LSTM模型通常包含一个或多个隐藏层。隐藏层可以帮助模型捕捉输入序列中的时间相关性，并存储和传递状态信息。每个隐藏层中都有许多LSTM单元（也称为LSTM块或LSTM单元），并且每个单元都具有自己的隐藏状态和记忆状态。

建lstm层时，为什么要将batch_first参数设可以直接使用这些数据处理库，无需进行额外的维度转换。置成True，作用是什么：

chatgpt：大多数神经网络模型通常将批处理维度放在第一个维度上。将LSTM的输入与其他模型保持一致，可以更容易地与其他模型进行结合。可以直接使用这些数据处理库，无需进行额外的维度转换。

关于优化器和模型裁剪，为防止梯度爆炸的疑问和理解

correct = np.squeeze(correct_tensor.cpu().numpy())将预测值张量（pred）从GPU转移到CPU，并将其转换为NumPy数组。为什么要转移到CPU?

chatgpt：因为GPU主要用于加速大规模的并行计算。在深度学习中，模型的训练和预测通常都是在CPU上进行的，因为CPU的单核性能比较高，适合处理复杂的逻辑和大量的数学运算。

评估中注释的squeeze , "test_loss = criterion(output.squeeze(), labels.float())"，为什么上面建造模型的时候不用？

有些问题还待更新，欢迎评论区解答

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

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