本篇文章参考：
Transformers for Sentiment Analysis.ipynb
部分细节可能会略作改动，代码注释尽数基于自己的理解。文章目的仅作个人领悟记录，并不完全是tutorial的翻译，可能并不适用所有初学者，但也可从中互相借鉴吸收参考。
接上篇：torchtext使用-- 单标签多分类任务TREC
这是第六篇，也是入门的最后一篇
这次我们将使用BERT来训练IMDB，虽然这听上去很不可思议。但是作为初学者学习BERT的使用，下游任务简单点也未尝不可
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchtext
from torchtext import data
from torchtext import datasets
import spacy
import random
import math
import numpy as np
use_cuda=torch.cuda.is_available()
device=torch.device("cuda" if use_cuda else "cpu")
SEED=1234
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
if use_cuda:
torch.cuda.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
由于BERT预训练有自己确定的分词方法和词表，因此对于IMDB数据的处理将使用transformer内部预置的BERT分词器
from transformers import BertTokenizer
tokenizer=BertTokenizer.from_pretrained('bert-base-uncased')
可以查看一下词表
len(tokenizer.vocab)
30522
对于一个句子的分词，只需要调用tokenizer的tokenize方法
token=tokenizer.tokenize("Don't Make sUch a fuss,get StUFf!")
print(token)
['don', "'", 't', 'make', 'such', 'a', 'fuss', ',', 'get', 'stuff', '!']
可以调用内部的convert_tokens_to_ids方法，将token序列化
indexes=tokenizer.convert_tokens_to_ids(token)
print(indexes)
[2123, 1005, 1056, 2191, 2107, 1037, 28554, 1010, 2131, 4933, 999]
由于我们最终还是要使用Field来处理IMDB的数据据，所以Field必须针对BERT的tokenizer做出调整，主要有以下两个调整
1.特殊token
BERT在预训练的时候为了能够学到句子级别的特征，将输入改为一个个句对。针对句对，BERT采用了两个特殊的token:[CLS]、[SEP].后者用来表示句子的结束标志，而前者则是针对整个句对的抽象特征，它将作为最高隐层，用来表示句子级别的信息。对BERT以及预训练模型陌生的同学可以参考文章： 最火的几个全网络预训练模型梳理整合（BERT、ALBERT、XLNet详解）
因此，在Field中必须把默认的token改为与BERT一致
cls_token=tokenizer.cls_token
sep_token=tokenizer.sep_token
pad_token=tokenizer.pad_token
unk_token=tokenizer.unk_token
print(cls_token,sep_token,pad_token,unk_token)
[CLS] [SEP] [PAD] [UNK]
也可以直接得到idx
cls_token_id=tokenizer.cls_token_id
sep_token_id=tokenizer.sep_token_id
pad_token_id=tokenizer.pad_token_id
unk_token_id=tokenizer.unk_token_id
print(cls_token_id,sep_token_id, pad_token_id, unk_token_id)
101 102 0 100
2.输入长度限制
由于不同的BERT模型对于输入的最大长度要求可能不同，因此我们可以通过max_model_input_sizes来查看。同时在Field中也要指定最大长度的处理
max_model_input_sizes是一个字典，包含了各种BERT的最大长度限制
type(tokenizer.max_model_input_sizes)
dict
len(tokenizer.max_model_input_sizes)
18
而我们这里使用的是bert-base-uncased
max_input_length = tokenizer.max_model_input_sizes['bert-base-uncased']
print(max_input_length)
512
所以对于我们训练数据的每一个句子，我们要保证喂给BERT前长度已经被cut过(当句子长度大于512)
要注意的是，由于BERT采用[CLS]、[SEP] 因此它对于这两个特有的句子级别token是敏感的，因为BERT会把它们视为句子的开始和结束。也就是说，如果我们对于训练的数据不加上这两个开始、结束符号，这对于BERT的施展是有影响的。因此，这里必须空出2个token留给[CLS]、[SEP];同时，在Field中也要指定init_token和eos_token为这两个标记
def tokenize_and_cut(sentence):
tokens=tokenizer.tokenize(sentence)
tokens=tokens[:max_input_length-2] #空出两个位置，让Field加上开始和结束的标记（[CLS]、[SEP]）
return tokens
接下来就是数据准备
1.Field
总结一下Field应该做出的调整：
1）.更改tokenize.这里不再使用spacy，而是调用tokenize_and_cut
2）.关闭vocab.由于我们已经有了tokenizer，因此在Field中我们需要指定use_vocab = False。也就是我们不需要Field来给分词之后的输入做序列化。
3）.指定preprocessing为序列化.我们都知道preprocessing预处理是先于序列化的。因为关闭了vocab，Field将没办法自动对token进行序列化操作，所以我们指定preprocessing为tokenizer.convert_tokens_to_ids，这样在分词之后可以调用preprocessing代替Field原先的自动序列化。
4）.指定特殊的token.这里需要指定四个token,即PAD\UNK\INIT\EOS。前面已经保证空出了两个位置留给INIT\EOS，所以这里可以放心地指定init_token = init_token_idx、eos_token = eos_token_idx,它会自动在sentence首位填充这两个token的idx。（要注意我们这里已经没有序列化的操作，而是preprocessing代替原先的序列化。而添加首位token这一步操作是在preprocessing和原先的序列化之间的。因此在这里，我们添加的token必须是token_idx,否则preprocessing将没办法把首尾token序列化）
5).设置batch_first = True.BERT要求输入的第一维是batch
TEXT=data.Field(batch_first=True,use_vocab=False,tokenize=tokenize_and_cut,
preprocessing=tokenizer.convert_tokens_to_ids,
init_token=cls_token_id,
eos_token=sep_token_id,
pad_token=pad_token_id,
unk_token=unk_token_id)
LABEL=data.LabelField(dtype=torch.float)
2.datasets
train_data, test_data =datasets.IMDB.splits(TEXT,LABEL)
train_data,valid_data=train_data.split(split_ratio=0.7)
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
可以看到，经过这样的Field处理的IMDB数据将会被序列化为BERT“认识的”句子
print(vars(train_data.examples[0]))
{'text': [2023, 3185, 2038, 2288, 2000, 2022, 2028, 1997, 1996, 5409, 1045, 2031, 2412, 2464, 2191, 2009, 2000, 4966, 999, 999, 999, 1996, 2466, 2240, 2453, 2031, 13886, 2065, 1996, 2143, 2018, 2062, 4804, 1998, 4898, 2008, 2052, 2031, 3013, 1996, 14652, 1998, 5305, 2135, 5019, 2008, 1045, 3811, 14046, 3008, 2006, 1012, 1012, 1012, 1012, 2021, 1996, 2466, 2240, 2003, 2066, 1037, 6065, 8854, 1012, 2065, 2045, 2001, 2107, 1037, 2518, 2004, 1037, 3298, 27046, 3185, 9338, 1011, 2023, 2028, 2052, 2031, 22057, 2013, 2008, 1012, 2009, 6966, 2033, 1037, 2843, 1997, 1996, 4248, 2666, 3152, 2008, 2020, 2404, 2041, 1999, 1996, 3624, 1005, 1055, 1010, 3532, 5896, 3015, 1998, 7467, 1012, 1026, 7987, 1013, 1028, 1026, 7987, 1013, 1028, 1996, 2069, 21082, 3494, 1999, 1996, 2878, 3185, 2001, 1996, 15812, 1998, 13570, 1012, 1996, 2717, 1997, 1996, 2143, 1010, 2071, 2031, 4089, 2042, 2081, 2011, 2690, 2082, 2336, 1012, 1045, 2507, 2023, 2143, 1037, 5790, 1997, 1015, 2004, 2009, 2003, 5621, 9643, 1998, 2187, 2026, 2972, 2155, 2007, 1037, 3168, 1997, 2108, 22673, 1012, 2026, 6040, 1011, 2123, 1005, 1056, 3422, 2009, 999, 999, 999], 'label': 'neg'}
3.vocab
这里只需要再构造LABEL的词表
LABEL.build_vocab(train_data)
4.iterator
BATCH_SIZE = 128
train_iterator, valid_iterator, test_iterator=data.BucketIterator.splits(
(train_data,valid_data,test_data),
batch_size=BATCH_SIZE,
device=device)
构建模型
这里会下载BERT的预训练模型，大概500MB不到。
from transformers import BertModel
bert=BertModel.from_pretrained('bert-base-uncased')
模型定义
对于BertModel来说，它的返回由四个部分组成：
1.last_hidden_state ：（batch,seq,hidden_size）
整个输入的句子每一个token的隐层输出，也是我们这里将要用到的，可以将它作为embedding的替代
2.pooler_output：（batch,hidden_size）
输入句子第一个token的最高隐层。也就是[CLS]标记提取到的最终的句对级别的抽象信息。对于BERT的预训练来说，这个隐层信息将作为Next Sentence prediction任务的输入。然而我们这里将不会用到它，因为它对于情感分析来说效果不是很好。
This output is usually not a good summary of the semantic content of the input, you’re often better with averaging or pooling the sequence of hidden-states for the whole input sequence.
3.hidden_states：
一个元组，里面每个元素都是(batch,seq,hidden_size) 大小的FloatTensor，分别代表每一层的隐层和初始embedding的和
4.attentions:
一个元组，里面每个元素都是(batch,num_heads,seq,seq) 大小的FloatTensor，分别表示每一层的自注意力分数。
class BERTGRUSentiment(nn.Module):
def __init__(self,bert:BertModel,
hidden_dim:int,
output_dim:int,
n_layers:int,
bidirectional:bool,
dropout:float):
super(BERTGRUSentiment, self).__init__()
self.bert=bert
embedding_dim=bert.config.to_dict()['hidden_size']
self.rnn=nn.GRU(embedding_dim,hidden_dim,n_layers,
bidirectional=bidirectional,
batch_first=True,
dropout=0 if n_layers<2 else dropout)
self.fc=nn.Linear(hidden_dim*2 if bidirectional else hidden_dim,output_dim)
self.dropout=nn.Dropout(dropout)
def forward(self,text):
with torch.no_grad():
embedding=self.bert(text)[0]
#embeddiing:(batch,seq,embedding_dim)
_,hidden=self.rnn(embedding)
#(bi*num_layers,batch,hidden_size)
hidden=self.dropout(torch.cat((hidden[-1,:,:],hidden[-2,:,:]),dim=1) if self.rnn.bidirectional else hidden[-1,:,:])
return self.fc(hidden)
#（batch,output_dim）
模型实例化
HIDDEN_DIM = 256
OUTPUT_DIM = 1
N_LAYERS = 2
BIDIRECTIONAL = True
DROPOUT = 0.25
model = BERTGRUSentiment(bert,
HIDDEN_DIM,
OUTPUT_DIM,
N_LAYERS,
BIDIRECTIONAL,
DROPOUT)
注意！！在训练之前必须将模型中有关于BERT预训练的参数冻结
def freeze_parameters(model:nn.Module,demand:str):
for name, parameters in model.named_parameters():
if name.startswith(demand):
parameters.requires_grad = False
冻结：
freeze_parameters(model,'bert')
来数一下参与训练的参数：
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,759,169 trainable parameters
可以看到把BERT的参数冻结之后，整体模型参数还是比较少的。实际上要训练的就只是GRU和全连接层
训练模型
criterion=nn.BCEWithLogitsLoss()
criterion=criterion.to(device)
model=model.to(device)
optimizer=optim.Adam(model.parameters())
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.eq(y).float() #convert into float for division
acc = correct.sum() / len(correct)
return acc
def train(model:nn.Module, iterator:data.BucketIterator,
optimizer:optim.Adam, criterion:nn.BCEWithLogitsLoss):
epoch_loss = 0.
epoch_acc = 0.
model.train()
for batch in iterator:
preds=model(batch.text).squeeze(-1)
loss=criterion(preds,batch.label)
acc=binary_accuracy(preds,batch.label)
optimizer.zero_grad()
loss.backward()
optimizer.step()
epoch_loss+=loss.item()
epoch_acc+=acc.item()
return epoch_loss/len(iterator),epoch_acc/len(iterator)
def evaluate(model: nn.Module, iterator: data.BucketIterator,
criterion: nn.BCEWithLogitsLoss):
epoch_loss = 0.
epoch_acc = 0.
model.eval()
with torch.no_grad():
for batch in iterator:
preds = model(batch.text).squeeze(-1)
loss = criterion(preds, batch.label)
acc = binary_accuracy(preds, batch.label)
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
开始训练
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
注意，如果你的机子显存不够，那么下面的这段代码基本上是会报错的。这主要是因为前面把model参数搬到了GPU，BERT参数有又多得让人发指，这时候基本上4、5个G的显存已经直接被占用了，再继续训练下去，显存就会支撑不了模型的迭代。
可以选择colab跑跑看，有钱人就忽略吧
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(), 'tut6-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}%')
7329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
