PyTorch应用实战六：利用LSTM实现文本情感分类_基于pytorch使用lstm实现新闻文本分类任务

实验环境

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
2
3
4
5
6

1.8.0
0.9.0
3.2.4
1
2
3

实验内容

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
2
3
4
5
6

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() 
1
2
3
4
5
6
7
8
9
10
11
12

2.数据集预处理

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

text,label
1
2
3
4

(<torchtext.legacy.data.field.Field at 0x1d8055c3208>,
 <torchtext.legacy.data.field.LabelField at 0x1d8054eada0>)
1
2

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

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

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

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

这段程序用到了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_data、valid_data和test_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_
)
1
2
3
4
5
6

.vector_cache\glove.6B.zip: 862MB [09:42, 1.48MB/s]                               
100%|█████████▉| 399999/400000 [00:42<00:00, 9399.30it/s] 
1
2

这是一个用于构建词汇表（Vocabulary）的函数，它接受多个参数：

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

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

label.build_vocab(train_data)
1

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

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

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

device = 'cpu'  # 使用cpu
1

train_iter, valid_iter, test_iter = data.BucketIterator.splits(
    (train_data, valid_data, test_data),
    batch_size=args.batch_size,
    device=device
)
1
2
3
4
5

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

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

具体来说，训练、验证、测试数据集以及设备类型等参数传递给BucketIterator的split方法，该方法返回一个包含三个数据迭代器（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])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这段程序定义了一个名为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
             )
1
2
3
4
5
6

pretrained_embeddings = text.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
model.to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
1
2
3
4

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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))
1
2
3
4
5
6
7
8
9
10
11
12
13

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

附：系列文章