PyTorch应用实战六:利用LSTM实现文本情感分类

文章目录

  • 实验环境
  • 实验内容
    • 0.导入相关库
    • 1.参数设置
    • 2.数据集预处理
    • 3.定义神经网络模型
    • 4.训练模型
    • 5.验证模型
    • 6.测试模型
  • 附:系列文章

实验环境

python3.6 + pytorch1.8.0 + torchtext0.9.0 + nltk

import torch
import torchtext
import nltk
print(torch.__version__)
print(torchtext.__version__)
print(nltk.__version__)
1.8.0
0.9.0
3.2.4

实验内容

0.导入相关库

import torch
import torch.optim as optim
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torchtext.legacy import data, datasets

1.参数设置

class Args: 
    max_vocab_size = 25000  # 限定词表最大规模
    n_labels = 5            # 情感类别个数
    epochs = 5              # 训练总周期
    embedding_dim = 300     # 词向量维度
    hidden_dim = 512        # LSTMCell隐层维度
    n_layers = 3            # LSTM层数
    batch_size = 64         # 批样本量大小
    display_freq = 50       # 输出信息间隔
    lr= 0.01                # 学习率
# 实例化
args = Args() 

2.数据集预处理

text = data.Field()
label = data.LabelField(dtype = torch.float)

text,label
(,
 )

这段代码使用了torchtext库中的两个类,用于定义文本数据集的字段和标签。具体作用如下:

  • data.Field类用于表示样本中的文本数据字段。它定义了文本数据的预处理方式(如分词、去除停用词、转为小写等),以及如何构建词汇表(Vocabulary)。当读取数据集时,文本数据会被自动进行相应的预处理,并且会根据Vocabulary将文本数据转换为数值型数据。此外,还可以通过设置该类的其他参数(如batch_first)来自定义数据的格式。
  • data.LabelField类用于表示样本的标签字段。它定义了标签数据的数据类型(如整型、浮点型等),并且可以将标签数据转换为数值型数据。在训练模型时,标签数据也会被用来计算损失函数。

总之,这两个类都是用来定义数据集中的字段,以便进行后续的处理和训练。在使用torchtext库时,定义字段是必要的一步。

train_data, valid_data, test_data = datasets.SST.splits(text, label, fine_grained=True)

这段程序用到了torchtext库中提供的SST数据集,SST全称为Stanford Sentiment Treebank,是一个情感分析的数据集,包含了电影评论的文本和对应的情感标签。

具体分析如下:

  • datasets.SST.splits(text, label, fine_grained=True):将SST数据集分成训练集、验证集和测试集。其中text参数表示文本字段,label参数表示标签字段,fine_grained=True表示使用细粒度情感标签。这个函数返回三个数据集对象,分别为训练集train_data、验证集valid_data和测试集test_data
  • train_datavalid_datatest_data都是torchtext.data.dataset.Dataset对象。这个对象中包含了数据集的所有实例,每个实例都包含了两个属性:text表示文本序列,label表示情感标签。

最终,这段程序的作用是将SST数据集加载进程序,分成训练集、验证集和测试集,并返回三个数据集对象,方便后续进行模型训练和测试。

text.build_vocab(
    train_data,
    max_size = args.max_vocab_size,
    vectors = "glove.6B.300d",
    unk_init = torch.Tensor.normal_
)
.vector_cache\glove.6B.zip: 862MB [09:42, 1.48MB/s]                               
100%|█████████▉| 399999/400000 [00:42<00:00, 9399.30it/s] 

这是一个用于构建词汇表(Vocabulary)的函数,它接受多个参数:

  • train_data:训练集数据,是一个由多个文本序列组成的列表或迭代器。
  • max_size:词汇表的最大大小,即最多包含多少个单词。如果不指定此参数,则默认为无限大。
  • vectors:词向量的预训练模型。在这里,使用了预训练的GloVe 300维词向量模型。如果不想使用预训练模型,则可以将此参数指定为None。
  • unk_init:当遇到不存在于预训练模型中的单词时,如何初始化它们的词向量。在这里,使用了正态分布作为初始化值。如果不指定此参数,则默认将所有未知单词的词向量初始化为0。

该函数的作用是将训练集中出现的所有单词加入到词汇表中,并为每个单词分配一个唯一的整数ID。同时,如果指定了预训练模型,则将相应单词的词向量加载到词汇表中。最终,该函数返回一个Vocab对象,其中包含词汇表信息和对应的词向量。

label.build_vocab(train_data)

这行代码是使用 train_data 数据集构建词汇表。词汇表是一个字典,将单词映射到一个唯一的整数值,使得后续处理可以更高效地处理文本数据。

具体来说,这个函数会遍历 train_data 中的所有句子,将其中所有的单词加入到词汇表中。此外,这个函数还可以进行一些额外的配置,例如设置最小出现次数、是否使用预训练的词向量等。

在使用词汇表时,每一个单词都会被替换为它在词汇表中对应的整数值,这个整数值可以作为模型输入的特征。如果有单词不在词汇表中,可以选择将它们替换为一个特殊的 单词或者忽略掉。

device = 'cpu'  # 使用cpu
train_iter, valid_iter, test_iter = data.BucketIterator.splits(
    (train_data, valid_data, test_data),
    batch_size=args.batch_size,
    device=device
)

该程序用于创建数据迭代器,以便在训练、验证和测试时批量处理数据。

首先,输入训练、验证和测试数据集以及一个批量大小参数。然后,程序使用PyTorch的BucketIterator类创建数据迭代器对象,该对象将数据按照指定的批量大小进行分批,并将其发送到指定的PyTorch设备上。

具体来说,训练、验证、测试数据集以及设备类型等参数传递给BucketIteratorsplit方法,该方法返回一个包含三个数据迭代器(train_iter、valid_iter和test_iter)的元组。这些迭代器可以用于遍历每个数据集,并按照指定的批量大小将数据分成批次。

在训练网络时,我们可以使用train_iter迭代器遍历训练数据集的所有批次,并使用每个批次来更新模型的权重。验证和测试也可以使用valid_iter和test_iter迭代器遍历验证和测试数据集,以便评估模型的性能。

3.定义神经网络模型

input_dim = len(text.vocab)
output_dim = args.n_labels

class Model(nn.Module):
    def __init__(self, in_dim, emb_dim, hid_dim, out_dim, n_layer):
        super(Model, self).__init__()
        self.embedding = nn.Embedding(in_dim, emb_dim)
        self.rnn = nn.LSTM(emb_dim, hid_dim, n_layer)
        self.linear = nn.Linear(hid_dim, out_dim)
        self.n_layer = n_layer
        self.hid_dim = hid_dim
        
    def forward(self, text):
        embedded = self.embedding(text)
        h0 = embedded.new_zeros(self.n_layer, embedded.size(1), self.hid_dim)
        c0 = embedded.new_zeros(self.n_layer, embedded.size(1), self.hid_dim)
        output, (hn, cn) = self.rnn(embedded, (h0, c0))
        return self.linear(output[-1])

这段程序定义了一个名为Model的自定义神经网络模型类。该模型包含四个模块:嵌入层、LSTM层、线性层和全连接层。其中,嵌入层将输入的词索引序列转化为对应的词向量表示,LSTM层通过学习输入序列之间的关系,提取文本信息,线性层将LSTM层最后一个时间步的输出映射到隐层状态,全连接层将隐层状态映射到输出向量。

具体来说,输入层的维度为词表的大小(即词表中的词数),输出层的维度为分类的类别数;嵌入层将输入的词索引映射为固定维度的词向量,LSTM层的隐藏状态维度为hid_dim,LSTM层的层数为n_layer;线性层将隐藏状态映射为输出向量。

在前向传播过程中,输入的词索引序列被首先映射为对应的词向量表示,然后在LSTM层中进行学习和提取文本信息的过程,最后通过线性层将LSTM层的最后一个时间步的输出映射到输出向量。

model = Model(input_dim, 
              args.embedding_dim, 
              args.hidden_dim,
              output_dim,
              args.n_layers
             )
pretrained_embeddings = text.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
model.to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)

4.训练模型

def train(epoch, model, iterator, optimizer):
    loss_list = []
    acc_list = []
    
    model.train()
    
    for i, batch in enumerate(iterator):
        optimizer.zero_grad()
        text = batch.text.to(device)
        label = batch.label.long().to(device)
        predictions = model(text)
        loss = F.cross_entropy(predictions, label)
        loss.backward()
        optimizer.step()
        
        acc = (predictions.max(1)[1] == label).float().mean()
        loss_list.append(loss.item())
        acc_list.append(acc.item())
        
        if i % args.display_freq == 0:
            print("Epoch %02d, Iter [%03d/%03d],"
                 "train loss = %.4f, train acc = %.4f" % (
                 epoch, i, len(iterator),
                 np.mean(loss_list), np.mean(acc_list)    
            ))
            loss_list.clear()
            acc_list.clear()

5.验证模型

def evaluate(epoch, model, iterator):
    val_loss = 0
    val_acc = 0
    model.eval()
    with torch.no_grad():
        for batch in iterator:
            text = batch.text.to(device)
            label = batch.label.long().to(device)
            predictions = model(text)
            loss = F.cross_entropy(predictions, label)
            acc = (predictions.max(1)[1] == label).float().mean()
            val_loss += loss.item()
            val_acc += acc.item()
    val_loss = val_loss / len(iterator)
    val_acc = val_acc / len(iterator)
    print('...Epoch %02d, val loss = %.4f, val acc = %.4f' % (
        epoch, val_loss, val_acc
    ))
    return val_loss, val_acc

6.测试模型

best_acc = 0
best_epoch = -1
for epoch in range(1, args.epochs + 1):
    train(epoch, model, train_iter, optimizer)
    valid_loss, valid_acc = evaluate(epoch, model, valid_iter)
    if valid_acc > best_acc:
        best_acc = valid_acc
    best_epoch = epoch
    torch.save(model.state_dict(),'best-model.pth')
print('Test best model @ Epoch %02d' % best_epoch)
model.load_state_dict(torch.load('best-model.pth'))
test_loss, test_acc = evaluate(epoch, model, test_iter)
print('Finally, test loss = %.4f, test acc = %.4f' % (test_loss, test_acc))
Epoch 01, Iter [000/134],train loss = 1.5556, train acc = 0.2031
Epoch 01, Iter [050/134],train loss = 1.5830, train acc = 0.2700
Epoch 01, Iter [100/134],train loss = 1.5819, train acc = 0.2631
...Epoch 01, val loss = 1.6984, val acc = 0.2533
Epoch 02, Iter [000/134],train loss = 1.5647, train acc = 0.2969
Epoch 02, Iter [050/134],train loss = 1.5870, train acc = 0.2678
Epoch 02, Iter [100/134],train loss = 1.5791, train acc = 0.2653
...Epoch 02, val loss = 1.5842, val acc = 0.2541
Epoch 03, Iter [000/134],train loss = 1.5969, train acc = 0.3125
Epoch 03, Iter [050/134],train loss = 1.5948, train acc = 0.2628
Epoch 03, Iter [100/134],train loss = 1.5919, train acc = 0.2659
...Epoch 03, val loss = 1.6012, val acc = 0.2767
Epoch 04, Iter [000/134],train loss = 1.5316, train acc = 0.2969
Epoch 04, Iter [050/134],train loss = 1.5864, train acc = 0.2753
Epoch 04, Iter [100/134],train loss = 1.5855, train acc = 0.2772
...Epoch 04, val loss = 1.5731, val acc = 0.2758
Epoch 05, Iter [000/134],train loss = 1.5888, train acc = 0.3125
Epoch 05, Iter [050/134],train loss = 1.5767, train acc = 0.2725
Epoch 05, Iter [100/134],train loss = 1.5942, train acc = 0.2731
...Epoch 05, val loss = 1.5772, val acc = 0.2621
Test best model @ Epoch 05
...Epoch 05, val loss = 1.5856, val acc = 0.2620
Finally, test loss = 1.5856, test acc = 0.2620

附:系列文章

序号 文章目录 直达链接
1 PyTorch应用实战一:实现卷积操作 https://want595.blog.csdn.net/article/details/132575530
2 PyTorch应用实战二:实现卷积神经网络进行图像分类 https://want595.blog.csdn.net/article/details/132575702
3 PyTorch应用实战三:构建神经网络 https://want595.blog.csdn.net/article/details/132575758
4 PyTorch应用实战四:基于PyTorch构建复杂应用 https://want595.blog.csdn.net/article/details/132625270
5 PyTorch应用实战五:实现二值化神经网络 https://want595.blog.csdn.net/article/details/132625348
6 PyTorch应用实战六:利用LSTM实现文本情感分类 https://want595.blog.csdn.net/article/details/132625382

你可能感兴趣的:(《,深度学习,》,pytorch,lstm,分类)