1.简单的GitHub pytorch sentiment analysis

1 - Simple Sentiment Analysis

在这篇文章中,会构建一个机器学习模型来检测句子的情感,使用PyTorch和TorchTest,使用的是IMDb dataset

最开始,只是做个简单的介绍,便于理解概念,并不关心是否会得到好的分类结果.之后的notebook会基于本章的基础知识构建好的模型

2 - 介绍

这里我们使用recurrent neural network(RNN)模型

3 - 准备数据

TorchText的一个主要概念是Field,它定义了你的数据如何被预处理的.(Field有点类似工具包/函数的概念)
在情感分类任务,数据包含了原始的评论文本,以及情感(pos or neg)

Field的参数决定了如何预处理数据:使用TEXT field来定义如何处理评论数据,LABEL field定义如何处理sentiment标签

Text field 使用tokenize='spacy'作为参数,定义了tokenization会使用spaCy的分词工具.如果没有传入tokenize参数,默认只会根据空格进行分词

LABEL是由一个LabelField定义的,一个特殊的Field 类的子集用于处理label用的.
设置随机种子,为了复现

import torch
from torchtext import data

SEED = 1234

torch.manual_seed(SEED)
torch.backends.cudnn.deterministic = True

TEXT = data.Field(tokenize = 'spacy')
LABEL = data.LabelField(dtype = torch.float)

以下代码会自动下载IMDB数据.并分成测试集和训练集,包含了5万条电影评论,每个都有标签

from torchtext import datasets

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

看一下训练集测试集都有多少数据

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

Number of training examples: 25000
Number of testing examples: 25000

构建验证机

import random

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

查看数据集

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

Number of training examples: 17500
Number of validation examples: 7500
Number of testing examples: 25000

3.1 构建词汇表

构建一个有效的查询表,其中每一个unique单词都有一个对应的索引index

我们这么做是因为机器学习不能处理字符串,只能是数字.每个单词和索引对应一个one-hot向量.维度就是在你词汇表中所有unique单词的数量

在训练集中unique单词数量超过10万,意味着词向量会超过10万维,这会使得训练变慢,还可能与GPU不适配

有两种方法有效的减少词汇量,可以只选择top n个最常用的单词 或忽略出现次数小于m次的单词.我们采用的是前者,保留top 25000个词

对于那些被砍掉的单词怎么办呢,我们会把他们替换成特殊的unknown 或<unk> token.

MAX_VOCAB_SIZE = 25_000

TEXT.build_vocab(train_data, max_size = MAX_VOCAB_SIZE)
LABEL.build_vocab(train_data)

Unique tokens in TEXT vocabulary: 25002
Unique tokens in LABEL vocabulary: 2

为什么是25002而不是25000?因为多了一个<unk>和<pad> token

查看自会表里最常见的词

print(TEXT.vocab.freqs.most_common(20))

[(‘the’, 203566), (’,’, 192495), (’.’, 165612), (‘and’, 109442), (‘a’, 109116), (‘of’, 100702), (‘to’, 93766), (‘is’, 76328), (‘in’, 61255), (‘I’, 54004), (‘it’, 53508), (‘that’, 49187), (’"’, 44282), ("‘s", 43329), (‘this’, 42445), (’-’, 36690), (’/><br’, 35752), (‘was’, 35034), (‘as’, 30384), (‘with’, 29774)]

查看labels,确认negative是0,positive是1

print(LABEL.vocab.stoi)

3.2 构建迭代器

我们使用BucketIterator,一种特殊的迭代器,并设置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)

4. 构建模型

这里只是在Pytorch中构建模型时用到的较小的样板代码,用于展示RNN类是如何继承父类nn.Module

在__init__ 中我们定义了模块的层,有三层结构,分别是

嵌入层embedding layer,
RNN层,
linear layer线性连接层

每一层除非明确指定,都是随机值初始化

嵌入层embedding layer是用来将稀疏的向量转化成密集向量,通常是简单的全连接层,将输入维度降低后在输入进RNN层
(有个理论说:对于评论的情感极性有相似影响力的词,在密集的维度空间中,会比较靠近.)

最后,线性连接层获取RNN的最后的hidden state,进行全连接,
前向传播方法forward method 会被调用,当我们将样本输入模型时

import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):
        
        super().__init__()
        
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        
        self.rnn = nn.RNN(embedding_dim, hidden_dim)
        
        self.fc = nn.Linear(hidden_dim, output_dim)
        
    def forward(self, text):

        #text = [sent len, batch size]
        
        embedded = self.embedding(text)
        
        #embedded = [sent len, batch size, emb dim]
        
        output, hidden = self.rnn(embedded)
        
        #output = [sent len, batch size, hid dim]
        #hidden = [1, batch size, hid dim]
        
        assert torch.equal(output[-1,:,:], hidden.squeeze(0))
        
        return self.fc(hidden.squeeze(0))

INPUT_DIM = len(TEXT.vocab) #词汇表数量
EMBEDDING_DIM = 100 # 压缩后的词向量维度,通常在50-250之间
HIDDEN_DIM = 256 #hidden states的大小,通常100-500维
OUTPUT_DIM = 1

model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)

构造一个函数,看一看这个模型中有多少参数是要训练的

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')

The model has 2,592,105 trainable parameters

5.训练模型

5.1 构造优化器

创建一个优化器用于更新模型的参数.这里我们使用的是随机梯度下降(stochastic gradient descent )
第一个参数是那些会被优化器更新的模型参数,第二个参数是学习率

import torch.optim as optim

optimizer = optim.SGD(model.parameters(), lr=1e-3)

5.2 定义损失函数

在PyTorch中损失函数通常叫做criterion(标准)

这里的损失函数是带有logits的二值交叉熵(binary cross entropy with logits)
logits是softmax前一步的向量,或理解成最后一层输出
因为我们的模型输出是一个未确定的实数,因为我们的标签不是0就是1,所以使用sigmoid或logit函数来将预测值限制在0,1之间

#BCEWithLogitsLoss包含了sigmoid和二值交叉熵.
criterion = nn.BCEWithLogitsLoss()

将其放入gpu中训练

model = model.to(device)
criterion = criterion.to(device) #损失函数

这里的损失函数criterion计算的是损失,然而我们要写个函数来计算精确度
这个函数首先将预测值输入到sigmoid层,将预测值压缩到0和1之间,在四舍五入,取其最接近的整数.[0.5-1]就是1,反之就是0
接着计算,有多少预测值与实际值匹配,

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

5.3 训练函数

train函数会一个batch一个batch的迭代训练样本
对于每一个batch,我们都要将梯度归零,每一个模型参数都有个grad属性,存储着损失函数计算出的梯度,Pytorch不会自动删除累计梯度,所以要手动归零

然后,我们将包含多个句子的batch(batch.text),输入模型.要注意的是不需要做model.forward(batch.text)只要简单的调用模型就行.
squeeze是需要的,因为最开始时预测值的size是[batch size, 1],我们需要将size 1的维度给去除,因为PyTorch希望预测值输入进损失函数criterion的形状是[batch size]

def train(model, iterator, optimizer, criterion):
    
    epoch_loss = 0
    epoch_acc = 0
    
    model.train()
    
    for batch in iterator:
        
        optimizer.zero_grad()
                
        predictions = model(batch.text).squeeze(1)
        
        loss = criterion(predictions, batch.label)
        
        acc = binary_accuracy(predictions, batch.label)
        
        loss.backward()
        
        optimizer.step()
        
        epoch_loss += loss.item()
        epoch_acc += acc.item()
        
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

5.4 评估模型

在no_grad()模块内,不会计算梯度,这样可以减少内存使用,加速计算,其他跟训练模块类似

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)

再创建一个函数来告诉每个epoch要训练多久,来比较不同模型的训练数据

import time

def epoch_time(start_time, end_time):
    elapsed_time = end_time - start_time
    elapsed_mins = int(elapsed_time / 60)
    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
    return elapsed_mins, elapsed_secs

6.正式训练

在每一轮epoch,如果验证集的损失值是目前为止最好的,我们会保留该模型的参数,然后训练结束后,我们会用这个最好的模型来测试

N_EPOCHS = 5

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(), 'tut1-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}%')

Epoch: 01 | Epoch Time: 0m 16s
Train Loss: 0.693 | Train Acc: 50.00%
Val. Loss: 0.694 | Val. Acc: 49.65%
Epoch: 02 | Epoch Time: 0m 16s
Train Loss: 0.693 | Train Acc: 49.97%
Val. Loss: 0.694 | Val. Acc: 49.81%
Epoch: 03 | Epoch Time: 0m 16s
Train Loss: 0.693 | Train Acc: 49.76%
Val. Loss: 0.695 | Val. Acc: 49.50%
Epoch: 04 | Epoch Time: 0m 16s
Train Loss: 0.693 | Train Acc: 50.24%
Val. Loss: 0.694 | Val. Acc: 50.70%
Epoch: 05 | Epoch Time: 0m 17s
Train Loss: 0.693 | Train Acc: 49.65%
Val. Loss: 0.695 | Val. Acc: 49.70%

可以看到结果并不好,这是因为很多问题我们没处理,这个模型只是用来走一遍流程

7.测试

model.load_state_dict(torch.load('tut1-model.pt'))

test_loss, test_acc = evaluate(model, test_iterator, criterion)

print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')

Test Loss: 0.686 | Test Acc: 58.99%