pytorch实战情感分析

实战链接：

https://github.com/ZeweiChu/PyTorch-Course/blob/master/notebooks/4.sentiment.ipynb

⭐️情感分类常用模型DAN。

Word Averaging模型 ，把每个单词都通过Embedding层投射成word embedding vector，然后把一句话中的所有word vector做个平均，就是整个句子的vector表示了。接下来把这个sentence vector传入一个Linear层，通过前向神经网络以及CrossEntropy就可以学习得到一句话的情感态度：正面（Positive）和 负面（Negative）。

如果能将句中单词转换为句向量，则可以更好的表达句子的语义💡。比如将句子带入双向RNN模型（或堆叠RNN）。取出最后一层的隐层向量，可以作为到每个句子的向量。单向RNN的最后一层更多的是距离较近的层的信息，因此双向RNN取出两端的参数求平均是一种更合理的方法。

⭐️下面通过电影评论进行文本分类的实战练习（sentiment）。

• 定义模型（搭建模型的前向传播过程）
• 初始化模型（embedding层设置为预训练的词向量）
• 训练/验证模型

torchText中的一个重要概念是Field。Field决定了你的数据会被怎样处理。在我们的情感分类任务中，我们所需要接触到的数据有文本字符串和两种情感，"pos"或者"neg"。

import torch
from torchtext import data

SEED = 1234

torch.manual_seed(SEED) #为CPU设置随机种子
torch.cuda.manual_seed(SEED)#为GPU设置随机种子

#在程序刚开始加这条语句可以提升一点训练速度，没什么额外开销。
torch.backends.cudnn.deterministic = True  

#用来定义字段的处理方法（文本字段，标签字段）
TEXT = data.Field(tokenize='spacy')#torchtext.data.Field : 
LABEL = data.LabelField(dtype=torch.float)

#首先，我们要创建两个Field 对象：这两个对象包含了我们打算如何预处理文本数据的信息。
#spaCy:英语分词器,类似于NLTK库，如果没有传递tokenize参数，则默认只是在空格上拆分字符串。
#LabelField是Field类的一个特殊子集，专门用于处理标签。 

下面的代码会自动下载IMDb数据集，然后分成train/test两个torchtext.datasets类别。数据被前面的Fields处理。IMDb数据集一共有50000电影评论，每个评论都被标注为正面的或负面的。

from torchtext import datasets
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)

⭐️查看每个数据split有多少条数据。

print(f'Number of training examples: {len(train_data)}')
print(f'Number of testing examples: {len(test_data)}')

⭐️查看一个example。

print(vars(train_data.examples[0]))

{'text': ['Brilliant', 'adaptation', 'of', 'the', 'novel', 'that', 'made', 'famous', 'the', 'relatives', 'of', 'Chilean'...'.'],'label': 'pos'}

其中"label"告诉我们当前评论的标签。

⭐️再将train数据集划分为train和test。

import random
train_data, valid_data = train_data.split(random_state=random.seed(SEED))

默认的数据分割是 70、30，如果我们声明split_ratio💡，可以改变split之间的比例，split_ratio=0.8表示80%的数据是训练集，20%是验证集。我们还声明random_state这个参数，确保我们每次分割的数据集都是一样的。

当我们把句子传进模型的时候，我们是按照一个个batch穿进去的，也就是说，我们一次传入了好几个句子，而且每个batch中的句子必须是相同的长度。为了确保句子的长度相同，TorchText会把短的句子pad到和最长的句子等长。

⭐️下一步我们需要创建vocabulary。vocabulary就是把每个单词一一映射到一个数字。我们使用最常见的25k个单词来构建我们的单词表，用max_size这个参数可以做到这一点。所有其他的单词都用<unk>来表示。

TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d",
                 unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)

词典中应当有25002个单词，且有两个label。可以通过TEXT.vocab和TEXT.label查询。我们可以直接用stoi(stringtoint) 或者itos(inttostring) 来查看我们的单词表。前面的文章中有多次应用。

print(TEXT.vocab.itos[:10])

['<unk>', '<pad>', 'the', ',', '.', 'a', 'and', 'of', 'to', 'is']

print(LABEL.vocab.stoi)

defaultdict(<function _default_unk_index at 0x7fbec39a79d8>, {'neg': 0, 'pos': 1})

⭐️最后一步数据的准备是创建iterators。每个itartion都会返回一个batch的examples。我们会使用BucketIterator。BucketIterator会把长度差不多的句子放到同一个batch中，确保每个batch中不出现太多的padding。这里因为pad比较少，所以把<pad>也当做了模型的输入进行训练。如果我们有GPU，还可以指定每个iteration返回的tensor都在GPU上。

BATCH_SIZE = 64

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

train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, valid_data, test_data), 
    batch_size=BATCH_SIZE,
    device=device)

3个iterator中各有两个部分：词（.text）和标签（.label）。其中text全部转换为数字了。

⭐️接下来使用Word Averaging模型进行训练。使用<u style="text-decoration: none; border-bottom-width: 1px; border-bottom-style: dashed; border-bottom-color: grey;">[avg_pool2d](https://link.zhihu.com/?target=https%3A//pytorch.org/docs/stable/nn.html%3Fhighlight%3Davg_pool2d%23torch.nn.functional.avg_pool2d)</u>来做average pooling。我们的目标是把sentence length那个维度平均成1，然后保留embedding这个维度avg_pool2d的kernel size是 (embedded.shape[1], 1)，所以句子长度的那个维度会被压扁。

import torch.nn as nn
import torch.nn.functional as F

class WordAVGModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, output_dim, pad_idx):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx)
        self.fc = nn.Linear(embedding_dim, output_dim)

    def forward(self, text):
        embedded = self.embedding(text) # [sent_len, batch _size, emb_size]
        embedded = embedded.permute(1, 0, 2) # [batch size, sent len, emb dim]
        pooled = F.avg_pool2d(embedded, (embedded.shape[1], 1)).squeeze(1) # [batch size, embedding_dim]
        return self.fc(pooled)

.squeeze(1)将1维的向量删掉。接下来定义一些参数。

INPUT_DIM = len(TEXT.vocab) #词个数
EMBEDDING_DIM = 100 #词嵌入维度
OUTPUT_DIM = 1 #输出维度
PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token] #pad索引

model = WordAVGModel(INPUT_DIM, EMBEDDING_DIM, OUTPUT_DIM, PAD_IDX)

⭐️定义一个函数，用来监控模型的参数数量。当参数.requires_grad==True的时候说明这些参数是可以被训练的。

def count_parameters(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

print(f'The model has {count_parameters(model):,} trainable parameters')

⭐️下面使用预训练过的embedding来替换随机初始化。

pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)

注意一下，.copy_()这种带着下划线的函数，均代表替换（inplace）。

⭐️将未知和pad的embedding设置为0。

UNK_IDX = TEXT.vocab.stoi[TEXT.unk_token]

model.embedding.weight.data[UNK_IDX] = torch.zeros(EMBEDDING_DIM)
model.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)

下面开始训练模型。首先定义模型和损失函数。BCEWithLogitsLoss其实就是针对二分类的CrossEntropy，通常在二分类任务中效果更好。他的输出没有经过sigmoid转换，所以需要做一个标准化。

import torch.optim as optim

optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()
model = model.to(device)
criterion = criterion.to(device)

⭐️定义一个函数用于计算准确率。

def binary_accuracy(preds, y):
    """
    Returns accuracy per batch, i.e. if you get 8/10 right, this returns 0.8, NOT 8
    """

    #round predictions to the closest integer
    rounded_preds = torch.round(torch.sigmoid(preds))
    correct = (rounded_preds == y).float() #convert into float for division 
    acc = correct.sum()/len(correct)
    return acc

⭐️定义一个训练函数。

def train(model, iterator, optimizer, criterion):

    epoch_loss = 0
    epoch_acc = 0
    total_len = 0
    model.train() #model.train()代表了训练模式
    #这步一定要加，是为了区分model训练和测试的模式的。
    #有时候训练时会用到dropout、归一化等方法，但是测试的时候不能用dropout等方法。

    for batch in iterator: #iterator为train_iterator
        optimizer.zero_grad() #加这步防止梯度叠加

        predictions = model(batch.text).squeeze(1)
        #batch.text 就是上面forward函数的参数text
        #压缩维度，不然跟batch.label维度对不上

        loss = criterion(predictions, batch.label)
        acc = binary_accuracy(predictions, batch.label)

        loss.backward() #反向传播
        optimizer.step() #梯度下降

        epoch_loss += loss.item() * len(batch.label)
        #loss.item()已经本身除以了len(batch.label)
        #所以得再乘一次，得到一个batch的损失，累加得到所有样本损失。

        epoch_acc += acc.item() * len(batch.label)
        #（acc.item()：一个batch的正确率） *batch数 = 正确数
        #train_iterator所有batch的正确数累加。

        total_len += len(batch.label)
        #计算train_iterator所有样本的数量，不出意外应该是17500

    return epoch_loss / total_len, epoch_acc / total_len
    #epoch_loss / total_len ：train_iterator所有batch的损失
    #epoch_acc / total_len ：train_iterator所有batch的正确率

⭐️再定义一个评估函数。和训练函数高度重合。区别是要吧model.train()改为model.val()，然后不需要反向传播的过程，并在最后重新调整为model.train()。另外中间步骤可以不保存梯度。

def evaluate(model, iterator, criterion):

    epoch_loss = 0
    epoch_acc = 0
    model.eval()

    with torch.no_grad():
        for batch in iterator:
            predictions = model(batch.text).squeeze(1)
            loss = criterion(predictions, batch.label)
            acc = binary_accuracy(predictions, batch.label)
            epoch_loss += loss.item()
            epoch_acc += acc.item()

    return epoch_loss / len(iterator), epoch_acc / len(iterator)

接下来开始训练并打印模型的表现。内容和之前的文章中几乎一致。

N_EPOCHS = 10

best_valid_loss = float('inf') #无穷大

for epoch in range(N_EPOCHS):

    start_time = time.time()

    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
    valid_loss, valid_acc = evaluate(model, valid_iterator, criterion)

    end_time = time.time()

    epoch_mins, epoch_secs = epoch_time(start_time, end_time)

    if valid_loss < best_valid_loss: #只要模型效果变好，就存模型
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'wordavg-model.pt')

    print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')
    print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')
    print(f'\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc*100:.2f}%')

⭐️接下来用保存的模型参数预测数据。

model.load_state_dict(torch.load("wordavg-model.pt"))

import spacy  #分词工具，跟NLTK类似
nlp = spacy.load('en')

def predict_sentiment(sentence):
    tokenized = [tok.text for tok in nlp.tokenizer(sentence)]#分词
    indexed = [TEXT.vocab.stoi[t] for t in tokenized] 
    #sentence的索引

    tensor = torch.LongTensor(indexed).to(device) #seq_len
    tensor = tensor.unsqueeze(1) #seq_len * batch_size（1）

    prediction = torch.sigmoid(model(tensor))
    #tensor与text一样的tensor

    return prediction.item()

⭐️使用自定义的语句做个实验。

predict_sentiment("I love This film badly ")

注意：

train之前需要model.train()
对于model、data都需要进行to(device)
关于criterion传入参数，第一个参数是模型输出output，是向量，而第二个参数label是groundtruth，是一个标量
当我们需要将模型中变量提取出来参与计算时，需要.item()