手把手教你用Pytorch-Transformers——實戰（二）

本文是《手把手教你用Pytorch-Transformers》的第二篇，主要講實戰

手把手教你用Pytorch-Transformers——部分源碼解讀及相關說明（一）

使用 PyTorch 的可以結合使用 Apex ，加速訓練和減小顯存的占用

PyTorch必備神器 | 唯快不破：基於Apex的混合精度加速

github托管地址：https://github.com/NVIDIA/apex

情感分類任務

這里使用 BertForSequenceClassification 進行情感分類任務，還是用 蘇劍林 整理的情感二分類數據集

可以結合之前發的那篇一起看，由於官方的 examples 還沒細看，這里的例子使用 PyTorch 比較傳統的方式進行訓練

數據集：

原始Github鏈接：https://github.com/bojone/bert4keras/tree/master/examples/datasets

個人網盤：鏈接: https://pan.baidu.com/s/1OAhNbRYpU1HW25_vChdRng 提取碼: uxax 

用Dataset表示數據集

先放上一些參數設置

# 超參數
hidden_dropout_prob = 0.3
num_labels = 2
learning_rate = 1e-5
weight_decay = 1e-2
epochs = 2
batch_size = 16

繼承 PyTorch 的 Dataset ，編寫一個類表示數據集，這里我們用字典返回一個樣本和它的標簽

from torch.utils.data import Dataset
import pandas as pd

class SentimentDataset(Dataset):
    def __init__(self, path_to_file):
        self.dataset = pd.read_csv(path_to_file, sep="\t", names=["text", "label"])
    def __len__(self):
        return len(self.dataset)
    def __getitem__(self, idx):
        text = self.dataset.loc[idx, "text"]
        label = self.dataset.loc[idx, "label"]
        sample = {"text": text, "label": label}
        return sample

編寫模型

Transformers 已經實現好了用來分類的模型，我們這里就不自己編寫了，直接使用 BertForSequenceClassification 調用預訓練模型

一些自定義的配置可以通過 BertConfig 傳遞給 BertForSequenceClassification

from transformers import BertConfig, BertForSequenceClassification
# 使用GPU
# 通過model.to(device)的方式使用
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
config = BertConfig.from_pretrained("bert-base-uncased", num_labels=num_labels, hidden_dropout_prob=hidden_dropout_prob)
model = BertForSequenceClassification.from_pretrained("bert-base-uncased", config=config)
model.to(device)

想自定義編寫模型的話可以參考BertForSequenceClassification。另外，這個BertConfig還可以添加自定義的屬性，比如添加一個作者啥的

config = BertConfig.from_pretrained("bert-base-uncased", author="DogeCheng")

讀取數據集

用 DataLoader 得到一個迭代器，每次得到一個 batch_size 的數據

from torch.utils.data import DataLoader
data_path = "/data/sentiment/"
# 加載數據集
sentiment_train_set = SentimentDataset(data_path + "sentiment.train.data")
sentiment_train_loader = DataLoader(sentiment_train_set, batch_size=batch_size, shuffle=True, num_workers=2)

sentiment_valid_set = SentimentDataset(data_path + "sentiment.train.data")
sentiment_valid_loader = DataLoader(sentiment_valid_set, batch_size=batch_size, shuffle=False, num_workers=2)

數據處理

主要實現對文本進行 tokenization 和 padding 的函數

vocab_file = "PyTorch_Pretrained_Model/chinese_wwm_pytorch/vocab.txt"
tokenizer = BertTokenizer(vocab_file)

def convert_text_to_ids(tokenizer, text, max_len=100):
    if isinstance(text, str):
        tokenized_text = tokenizer.encode_plus(text, max_length=max_len, add_special_tokens=True)
        input_ids = tokenized_text["input_ids"]
        token_type_ids = tokenized_text["token_type_ids"]
    elif isinstance(text, list):
        input_ids = []
        token_type_ids = []
        for t in text:
            tokenized_text = tokenizer.encode_plus(t, max_length=max_len, add_special_tokens=True)
            input_ids.append(tokenized_text["input_ids"])
            token_type_ids.append(tokenized_text["token_type_ids"])
    else:
        print("Unexpected input")
    return input_ids, token_type_ids

def seq_padding(tokenizer, X):
    pad_id = tokenizer.convert_tokens_to_ids("[PAD]")
    if len(X) <= 1:
        return torch.tensor(X)
    L = [len(x) for x in X]
    ML = max(L)
    X = torch.Tensor([x + [pad_id] * (ML - len(x)) if len(x) < ML else x for x in X])
    return X

定義優化器和損失函數

其實從源碼看，我們知道 BertForSequenceClassification 已經有了損失函數，可以不用實現，這里展示一個更通用的例子，自己實現損失函數

import torch
import torch.nn as nn
from transformers import AdamW
# 定義優化器和損失函數
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
        {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': weight_decay},
        {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
#optimizer = AdamW(model.parameters(), lr=learning_rate)
optimizer = AdamW(optimizer_grouped_parameters, lr=learning_rate)
criterion = nn.CrossEntropyLoss()

從上面我們可以看到 bias 和 LayerNorm.weight 都沒用權重衰減，可以參考下面的博文，主要是由於 bias 的更新跟權重衰減無關

權重衰減（weight decay）與學習率衰減（learning rate decay）：

https://blog.csdn.net/program_developer/article/details/80867468

定義訓練和驗證函數

PyTorch 不像 Keras 那樣調用 fit 就可以了，大多都需要自己實現，為了復用性，這里用函數實現了簡單的訓練和測試函數

因為 BertForSequenceClassification 里面已經有了一個 CrossEntropyLoss() ，實際可以不用我們剛剛的實例化的損失函數，見 train() 函數 中的注釋

函數返回2個內容：一個 epoch 內的損失和准確率，如果要計算其他評估指標需自己實現（或通過 sklearn.metrics 幫助）

def train(model, iterator, optimizer, criterion, device):
    model.train()
    epoch_loss = 0
    epoch_acc = 0
    for i, batch in enumerate(iterator):
        label = batch["label"]
        text = batch["text"]
        input_ids, token_type_ids = convert_text_to_ids(tokenizer, text)
        input_ids = seq_padding(tokenizer, input_ids)
        token_type_ids = seq_padding(tokenizer, token_type_ids)
        # 標簽形狀為 (batch_size, 1) 
        label = label.unsqueeze(1)
        # 需要 LongTensor
        input_ids, token_type_ids, label = input_ids.long(), token_type_ids.long(), label.long()
        # 梯度清零
        optimizer.zero_grad()
        # 遷移到GPU
        input_ids, token_type_ids, label = input_ids.to(device), token_type_ids.to(device), label.to(device)
        output = model(input_ids=input_ids, token_type_ids=token_type_ids, labels=label)
        y_pred_prob = output[1]
        y_pred_label = y_pred_prob.argmax(dim=1)
        # 計算loss
        # 這個 loss 和 output[0] 是一樣的
        loss = criterion(y_pred_prob.view(-1, 2), label.view(-1))
        #loss = output[0]
        # 計算acc
        acc = ((y_pred_label == label.view(-1)).sum()).item()
        # 反向傳播
        loss.backward()
        optimizer.step()
        # epoch 中的 loss 和 acc 累加
        epoch_loss += loss.item()
        epoch_acc += acc
        if i % 200 == 0:
            print("current loss:", epoch_loss / (i+1), "\t", "current acc:", epoch_acc / ((i+1)*len(label)))
    # return epoch_loss / len(iterator), epoch_acc / (len(iterator) * iterator.batch_size)
    # 經評論區提醒修改
    return epoch_loss / len(iterator), epoch_acc / len(iterator.dataset.dataset)

def evaluate(model, iterator, criterion, device):
    model.eval()
    epoch_loss = 0
    epoch_acc = 0
    with torch.no_grad():
        for _, batch in enumerate(iterator):
            label = batch["label"]
            text = batch["text"]
            input_ids, token_type_ids = convert_text_to_ids(tokenizer, text)
            input_ids = seq_padding(tokenizer, input_ids)
            token_type_ids = seq_padding(tokenizer, token_type_ids)
            label = label.unsqueeze(1)
            input_ids, token_type_ids, label = input_ids.long(), token_type_ids.long(), label.long()
            input_ids, token_type_ids, label = input_ids.to(device), token_type_ids.to(device), label.to(device)
            output = model(input_ids=input_ids, token_type_ids=token_type_ids, labels=label)
            y_pred_label = output[1].argmax(dim=1)
            loss = output[0]
            acc = ((y_pred_label == label.view(-1)).sum()).item()
            epoch_loss += loss.item()
            epoch_acc += acc
    # return epoch_loss / len(iterator), epoch_acc / (len(iterator) * iterator.batch_size)
    # 經評論區提醒修改
    return epoch_loss / len(iterator), epoch_acc / len(iterator.dataset.dataset)

開始訓練

這里只跑了 2 個 epoch，在驗證集上的效果達到了 92 的准確率

# 再測試
for i in range(epochs):
    train_loss, train_acc = train(model, sentiment_train_loader, optimizer, criterion, device)
    print("train loss: ", train_loss, "\t", "train acc:", train_acc)
    valid_loss, valid_acc = evaluate(model, sentiment_valid_loader, criterion, device)
    print("valid loss: ", valid_loss, "\t", "valid acc:", valid_acc)

第一個 epoch

第二個 epoch

 SQuAD任務

官方例子的使用

這里直接使用 Transformers 提供 run_squad.py 進行說明

這里使用的是 SQuAD v1.1 數據集，下載地址為

• train-v1.1.json
• dev-v1.1.json

下載好數據后，放入 $SQUAD_DIR 中，輸入以下命令運行

export SQUAD_DIR=/path/to/SQUAD

python run_squad.py \
  --model_type bert \
  --model_name_or_path bert-base-cased \
  --do_train \
  --do_eval \
  --do_lower_case \
  --train_file $SQUAD_DIR/train-v1.1.json \
  --predict_file $SQUAD_DIR/dev-v1.1.json \
  --per_gpu_train_batch_size 12 \
  --learning_rate 3e-5 \
  --num_train_epochs 2.0 \
  --max_seq_length 384 \
  --doc_stride 128 \
  --output_dir /tmp/debug_squad/

utils_squad.py

SQuAD數據集是用JSON格式存儲的，而且層級很多，下面的鏈接有SQuAD數據集的結構化展示

https://blog.csdn.net/m0_38133212/article/details/87889949

我們主要使用到的是 paragraphs 字段的內容，包括context 和 qas

• qas 包括 answers，question 以及 id
• 而 answers 包括 answer_start 和 text

read_squad_examples()

read_squad_examples() 就是負責把原來的JSON數據抽取出來，讓數據變得更清晰。每條數據變成一個 SquadExample 對象，存放下面的內容

• qas_id：id
• question_text：question
• doc_tokens：經過 tokenization 后的 text
• orig_answer_text：text
• start_position：開始位置
• end_position：結束位置
• is_impossible：樣本是否沒有答案

其中 is_impossible 是SQuAD v2才有的字段，read_squad_examples() 會判斷數據集的版本，我們在運行 run_squad.py時，可以通過 --version_2_with_negative 參數設置

if version_2_with_negative:
    is_impossible = qa["is_impossible"]

數據集只提供了 answer_start，所以 end_position 需要自己計算，即 start_position 加上答案的長度-1

if not is_impossible:
    answer = qa["answers"][0]
    orig_answer_text = answer["text"]
    answer_offset = answer["answer_start"]
    answer_length = len(orig_answer_text)
    start_position = char_to_word_offset[answer_offset]
    end_position = char_to_word_offset[answer_offset + answer_length - 1]

convert_examples_to_features()

read_squad_examples() 負責從 JSON 中讀取數據，並進行一些處理，但是這樣不能輸入 Bert 模型中

所以還需要使用 convert_examples_to_features() 函數處理成能夠輸入到 Bert 中的格式，主要是截斷、padding 和 token轉換為id等

如簡單粗暴的截斷操作

if len(query_tokens) > max_query_length:
    query_tokens = query_tokens[0:max_query_length]

token 轉換成 id 和 mask 等操作

input_ids = tokenizer.convert_tokens_to_ids(tokens)

# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)

padding 操作

# Zero-pad up to the sequence length.
while len(input_ids) < max_seq_length:
    input_ids.append(pad_token)
    input_mask.append(0 if mask_padding_with_zero else 1)
    segment_ids.append(pad_token_segment_id)
    p_mask.append(1)

最后每個樣本用 InputFeatures 對象存放這些處理后的數據

run_squad.py

run_squad.py 用一個字典存放不同模型用到的Config、Model 和 Tokenizer，通過 --model_type 參數使用

MODEL_CLASSES = {
    'bert': (BertConfig, BertForQuestionAnswering, BertTokenizer),
    'xlnet': (XLNetConfig, XLNetForQuestionAnswering, XLNetTokenizer),
    'xlm': (XLMConfig, XLMForQuestionAnswering, XLMTokenizer),
    'distilbert': (DistilBertConfig, DistilBertForQuestionAnswering, DistilBertTokenizer),
    'albert': (AlbertConfig, AlbertForQuestionAnswering, AlbertTokenizer)
}

我們通過 --model_type 參數使用需要的模型，並在 main() 函數中實例化 config、model 和 tokenizer 對象

config_class, model_class, tokenizer_class = MODEL_CLASSES[args.model_type]

准備數據集

使用 read_squad_examples 處理再用 convert_examples_to_features 將每一個樣本用 InputFeatures 對象表示

再通過 load_and_cache_examples() 將數據全部變成張量，大致代碼如下

...
examples = read_squad_examples(input_file=input_file,
                                        is_training=not evaluate,
                                        version_2_with_negative=args.version_2_with_negative)
features = convert_examples_to_features(examples=examples,
                                        tokenizer=tokenizer,
                                        max_seq_length=args.max_seq_length,
                                        doc_stride=args.doc_stride,
                                        max_query_length=args.max_query_length,
                                        is_training=not evaluate,
                                        cls_token_segment_id=2 if args.model_type in ['xlnet'] else 0,
                                        pad_token_segment_id=3 if args.model_type in ['xlnet'] else 0,
                                        cls_token_at_end=True if args.model_type in ['xlnet'] else False,
                                        sequence_a_is_doc=True if args.model_type in ['xlnet'] else False)

...

# Convert to Tensors and build dataset
all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)
all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)
all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)
all_cls_index = torch.tensor([f.cls_index for f in features], dtype=torch.long)
all_p_mask = torch.tensor([f.p_mask for f in features], dtype=torch.float)
if evaluate:
    all_example_index = torch.arange(all_input_ids.size(0), dtype=torch.long)
    dataset = TensorDataset(all_input_ids, all_input_mask, all_segment_ids,
                            all_example_index, all_cls_index, all_p_mask)
else:
    all_start_positions = torch.tensor([f.start_position for f in features], dtype=torch.long)
    all_end_positions = torch.tensor([f.end_position for f in features], dtype=torch.long)
    dataset = TensorDataset(all_input_ids, all_input_mask, all_segment_ids,
                            all_start_positions, all_end_positions,
                            all_cls_index, all_p_mask)

if output_examples:
    return dataset, examples, features
return dataset

在 main() 函數中將這些數據變成張量后，再送到 train() 函數中

train_dataset = load_and_cache_examples(args, tokenizer, evaluate=False, output_examples=False)
global_step, tr_loss = train(args, train_dataset, model, tokenizer)

train()

這里也使用 DataLoader 將數據集變成生成器，用來取出一個 batch 的數據訓練

train_sampler = RandomSampler(train_dataset) if args.local_rank == -1 else DistributedSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size)

定義優化器

no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
    {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
    {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
    ]
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)

還使用了學習率預熱，訓練時先從小的學習率開始訓練

scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total)

如果機器上有 apex ，可以通過 --fp16 參數設置，進行加速訓練

if args.fp16:
    try:
        from apex import amp
    except ImportError:
        raise ImportError("Please install apex from https://www.github.com/nvidia/apex to use fp16 training.")
    model, optimizer = amp.initialize(model, optimizer, opt_level=args.fp16_opt_level)

訓練過程設置了 checkpoint，默認每 50 個 step 保存一次模型，可以通過 --save_steps 修改

if args.local_rank in [-1, 0] and args.save_steps > 0 and global_step % args.save_steps == 0:
    # Save model checkpoint
    output_dir = os.path.join(args.output_dir, 'checkpoint-{}'.format(global_step))
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    model_to_save = model.module if hasattr(model, 'module') else model  # Take care of distributed/parallel training
    model_to_save.save_pretrained(output_dir)
    torch.save(args, os.path.join(output_dir, 'training_args.bin'))
    logger.info("Saving model checkpoint to %s", output_dir)

在 BertForQuestionAnswering 中，它會把 sequence_output 送到一個全連接層中，轉換 hidden_size 維度為2，然后split輸出，得到 start_logits 和 end_logits

下面是 BertForQuestionAnswering 中的代碼片段，描述了上面說的過程

logits = self.qa_outputs(sequence_output)
start_logits, end_logits = logits.split(1, dim=-1)

start_logits 和 end_logits 就是每個 Bert 預測答案開始和結束位置的置信度，這個過程大致如下圖所示

BertForQuestionAnswering 計算損失的方式就是 start_logits 和 end_logits 分別計算 loss 再相加取平均

loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
start_loss = loss_fct(start_logits, start_positions)
end_loss = loss_fct(end_logits, end_positions)
total_loss = (start_loss + end_loss) / 2

evaluate()

如果設置了 --do_eval 參數，模型訓練完后會進行測試

預測完成后生成的文件有 predictions_.json 和 nbest_predictions_.json 等

其中 predictions_.json 記錄的是每個問題 id 對應的最佳答案，如下圖所示

nbest_predictions_.json 記錄的是每個問題 id 對應的 n 個最佳答案

這是我跑的結果