Transformers

一、API 总览

二、pipeline

2.1、pipeline 支持的任务场景（部分）

2.2、部分场景实现

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
result1 = classifier("I've been waiting for a HuggingFace course my whole life.")
result2 = classifier(["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"])   # 如果输入多个句子，需用列表
print(result1)

from transformers import pipeline

classifier = pipeline("zero-shot-classification")
result = classifier("This is a course about the Transformers library", 
										candidate_labels=["education", "politics", "business"],)   # 提供后选标签
print(result)

from transformers import pipeline

generator = pipeline("text-generation")
# generator = pipeline("text-generation", model="distilgpt2")   # 指定模型
results = generator(
    "In this course, we will teach you how to",
    num_return_sequences=2,
    max_length=50) 
print(results)

2.3、自定义 pipeline 模型

from transformers import pipeline

generator = pipeline("text-generation", model="distilgpt2")
results = generator(
    "In this course, we will teach you how to",
    max_length=30,
    num_return_sequences=2,)
print(results)

from transformers import AutoModelForSequenceClassification
from transformers import AutoTokenizer
from transformers import pipeline


model_path = r"../pretrained_model/IDEA-CCNL(Erlangshen-Roberta-110M-Sentiment)"
model = AutoModelForSequenceClassification.from_pretrained(model_path)   # 加载模型
tokenizer = AutoTokenizer.from_pretrained(model_path)                    # 加载分词器


classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
result = classifier("今天心情很好")
print(result)

三、模型加载、配置、保存

3.1、直接加载预训练模型

3.1.1、使用模型对应的 Model 类加载

from transformers import BertModel
from transformers import BartModel
from transformers import GPT2Model

model = BertModel.from_pretrained("bert-base-cased")
model = BertModel.from_pretrained("./models/bert/")   # 预先下载的模型目录

3.1.2、使用模型对应的 ModelForXXX 类加载

from transformers import BertForSequenceClassification

model_path = r"../pretrained_model/IDEA-CCNL(Erlangshen-Roberta-110M-Sentiment)"
model = BertForSequenceClassification.from_pretrained(model_path)

3.1.3、使用AutoModel 类加载

from transformers import AutoModel

model= AutoModel.from_pretrained("bert-base-cased")

3.1.4、使用AutoModelForXXX 类加载

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("LinkSoul/Chinese-Llama-2-7b")

• AutoModelForCausalLM, 用于自回归语言模型

• AutoModelForMaskedLM, 用于掩码语言模型

• AutoModelForSeq2SeqLM, 用于序列到序列的任务模型

• AutoModelForQuestionAnswering, 用于问答任务模型

• AutoModelForTokenClassification, 用于标记分类任务模型

• AutoModelForSequenceClassification, 用于序列分类任务模型

• AutoModelForMultipleChoice, 用于多选任务模型

• ……

3.1.5、模型权重加载注意事项

• 所有加载方式都能 使用名称加载 和本地路径加载，但由于名称加载方式需要连接网络，如果模型太大或者网络不好就会比较耗时，因此在大部分情况下我们都会采用本地路径的方式加载模型（预先下载的模型目录）。

• 部分模型的 Hub 页面中会包含很多文件，我们通常只需要下载模型对应的 config.json 和 pytorch_model.bin，以及分词器对应的 tokenizer.json、tokenizer_config.json 和 vocab.txt。

• 官方推荐使用 AutoModelForXXX 和 TFAutoModelXXX 加载预训练模型。

3.2、设定配置加载模型

3.2.1、随机初始化 config

from transformers import BertConfig
from transformers import BertModel


config = BertConfig()       # 随机初始化一个Bert的配置
model = BertModel(config)   # 用设定的config创建模型

3.2.2、从其他模型获取并修改 config

from transformers import AutoConfig
from transformers import AutoModel

model_id = "cardiffnlp/twitter-roberta-base-sentiment-latest"
my_config = AutoConfig.from_pretrained(model_id, num_attention_heads=11)   # 从其他模型获取并修改 config
my_model = AutoModel.from_config(my_config)      # 用设定的config创建模型

3.3、模型保存

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("ProsusAI/finbert")
model.save_pretrained('./model/ProsusAI/finbert')

• config.json：模型配置文件，包含了预训练模型的架构和各种超参数的设置。模型配置文件描述了模型的层次结构、注意力头数、隐藏层维度、词汇表大小等信息。

• pytorch_model.bin：模型权重文件，存了模型的权重参数，包含了模型在训练过程中学到的参数。(我生成的是model.safetensors？)

四、数据预处理

4.1、分词器 Tokenizer

4.1.1、加载与保存分词器

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
tokenizer.save_pretrained("./models/bert-base-cased/")


from transformers import AutoTokenizer   # 更推荐
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
tokenizer.save_pretrained("./models/bert-base-cased/")

• special_tokens_map.json：映射文件，里面包含 unknown token 等特殊字符的映射关系；

• tokenizer_config.json：分词器配置文件，存储构建分词器需要的参数；

• vocab.txt：词表，一行一个 token，行号就是对应的 token ID（从 0 开始）。

4.1.2、文本编码与解码

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
sequence = "Using a Transformer network is simple"


# 分步查看
tokens = tokenizer.tokenize(sequence)           # 分词：['Using', 'a', 'Trans', '##former', 'network', 'is', 'simple']
ids = tokenizer.convert_tokens_to_ids(tokens)   # 编码：[7993, 170, 13809, 23763, 2443, 1110, 3014]
sequence_ids = tokenizer.encode(sequence)       # 分词+编码+特殊字符：[101, 7993, 170, 13809, 23763, 2443, 1110, 3014, 102]


# 直接使用分词器进行处理（常用，可以直接处理多段文本）
tokenized_text = tokenizer(sequence)            
"""
{'input_ids': [101, 7993, 170, 13809, 23763, 2443, 1110, 3014, 102],    # 对应于句子中每个 token（词） 的索引
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],    # 当存在多个序列时，标识 token 属于那个序列（多个句子，标识词属于哪个句子）
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}    # 注意力机制掩码，
"""

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

decoded_string = tokenizer.decode([101, 7993, 170, 13809, 23763, 2443, 1110, 3014, 102])
""" [CLS] Using a Transformer network is simple [SEP] """
# BERT 分词器会分别在序列的首尾添加[CLS]和[SEP]

4.2、填充与截断

4.2.1、填充

• padding=True： 与padding="longest" 相同；

• padding="longest" ： 将序列填充到当前 batch 中最长序列的长度；

• padding="max_length"：将所有序列填充到模型能够接受的最大长度

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

batch_sentences = ["今天天气真好", "今天天气真好，适合出游"]
encoded_inputs = tokenizer(batch_sentences, padding=True)   # 填充

"""
{'input_ids':
 [[101, 791, 1921, 1921, 3698, 4696, 1962, 102, 0, 0, 0, 0, 0],
  [101, 791, 1921, 1921, 3698, 4696, 1962, 8024, 6844, 1394, 1139, 3952, 102]], 
'token_type_ids':
 [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
'attention_mask':
 [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}
"""

4.2.2、截断

1. 使用一个支持长文的 Transformer 模型，例如 Longformer 和 LED（最大长度 4096）；

2. 将长文切片为短文本块 (chunk)，然后分别对每一个 chunk 编码。在后面的快速分词器中，我们会详细介绍。

3. 截断序列
1. 设定最大长度 max_sequence_length 以截断输入序列：sequence = sequence[:max_sequence_length]。
2. 设置 tokenizer 的 truncation=True，同时可以配合max_length参数来设置要保留的长度。

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

sequences = [
    "I've been waiting for a HuggingFace course my whole life.", 
    "So have I!"]
encoded_inputs = tokenizer(sequences, max_length=8, truncation=True)   # 超过最大长度的内容全部截断

4.2.3、Tips

• return_tensors='pt' ：返回PyTorch 张量

• return_tensors='tf' ：返回TensorFlow 张量

• return_tensors='np' ：返回 NumPy 数组

4.3、添加 token

五、模型训练

5.1、Trainer

• 自动化训练循环：Trainer封装了训练和评估的循环，使训练过程更简单和一致。

• 批量处理和GPU加速：Trainer自动处理批量输入，使用GPU加速模型的训练和评估过程。

• 学习率调度器：Trainer支持多种学习率调度器，如线性衰减、余弦退火等，以帮助优化模型的训练过程。

• 模型检查点：Trainer可以自动保存训练过程中的模型检查点，以便在训练中断后能够恢复训练。

trainer = Trainer(
    model,                         #  要训练和评估的模型
    args,                          # 一个包含训练参数的TrainingArguments对象
    train_dataset=ds_train_enc,    # 训练数据集，一个Dataset对象
    eval_dataset=ds_valid_enc,     # 评估数据集，一个Dataset对象
    tokenizer=tokenizer,           # 用于对输入文本进行标记化的分词器
    compute_metrics=compute_metrics,# 用于计算评估指标的函数
    # do_save_full_model=True,       # 是否保存完整的模型，默认为 True
)

5.2、TrainingArguments

• 配置训练参数：TrainingArguments用于配置训练过程中的各种参数，如批量大小、学习率、训练步骤等。

• 参数优化和覆盖：可以通过TrainingArguments提供的方法来优化和覆盖训练参数，以满足具体需求。

• 从命令行解析参数：可以将命令行传递的参数与TrainingArguments的配置进行解析和合并。

• 保存和加载训练参数：可以将TrainingArguments的配置保存到文件中，以便在需要时进行加载和重用。

args = TrainingArguments(
    f"{model_name}-finetuned",       # output_dir保存模型和训练日志的目录
    evaluation_strategy = "steps",   # 评估策略，"no"（不评估），"steps"（按照一定步数评估），"epoch"（按照一定轮数评估）
    eval_steps = 230,                # 评估步数，在训练过程中每隔多少步进行一次评估
    save_strategy = "steps",         # 保存模型的策略。可选值包括"no"（不保存），"epoch"（按照一定轮数保存），"steps"（按照一定步数保存）。
    save_steps = 230,                # 保存步数，在训练过程中每隔多少步保存一次模型
    learning_rate=2e-5,              # 学习率
    per_device_train_batch_size=train_batch_size,   # 每个设备上的训练批量大小
    per_device_eval_batch_size=eval_batch_size,     # 每个设备上的评估批量大小
    gradient_accumulation_steps=grad_acc,           # 梯度累积的步数。当设为大于1的值时，将会累积多个小批次的梯度，达到大批次的效果。
    num_train_epochs=1,              # 训练轮数
    weight_decay=0.01,               # 权重衰减的程度，权重衰减是一种正则化技术，旨在降低模型的复杂度并减少过拟合的风险。
    load_best_model_at_end=False,    # 控制是否在训练结束时加载最佳模型，设置为False，则只会加载最后一次保存的模型
    metric_for_best_model=metric_name,# 指定用于选择最佳模型的评估指标。
    report_to='none',                # 指定要报告训练指标和日志的后端，需要确保已安装相应的后端库，并进行相应的配置。
    # seed=2   # 随机种子
)

from transformers import Trainer, TrainingArguments

# 定义模型和数据集
model = ...
train_dataset = ...
eval_dataset = ...

# 创建TrainingArguments对象
training_args = TrainingArguments(
    output_dir='./results',  # 输出目录
    num_train_epochs=3,      # 训练轮数
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',    # 日志目录
    logging_steps=100,
    evaluation_strategy='steps',
    eval_steps=500,
    save_strategy='epoch',
    save_steps=500,   
)

# 创建Trainer对象
trainer = Trainer(
    model=model,                         # 模型
    args=training_args,                  # 训练参数
    train_dataset=train_dataset,         # 训练数据集
    eval_dataset=eval_dataset            # 验证数据集
)

# 开始训练
trainer.train()

六、微调预训练模型

import random
import os
import numpy as np
import json
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader
from transformers import AutoTokenizer, AutoConfig
from transformers import BertPreTrainedModel, BertModel
from transformers import AdamW, get_scheduler
from tqdm.auto import tqdm

def seed_everything(seed=1029):
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    # some cudnn methods can be random even after fixing the seed
    # unless you tell it to be deterministic
    torch.backends.cudnn.deterministic = True

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f'Using {device} device')
seed_everything(42)

learning_rate = 1e-5
batch_size = 4
epoch_num = 3

checkpoint = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

class AFQMC(Dataset):
    def __init__(self, data_file):
        self.data = self.load_data(data_file)
    
    def load_data(self, data_file):
        Data = {}
        with open(data_file, 'rt') as f:
            for idx, line in enumerate(f):
                sample = json.loads(line.strip())
                Data[idx] = sample
        return Data
    
    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

public_path = '../data/蚂蚁金融语义相似度数据集AFQMC/'
train_data = AFQMC(public_path + 'afqmc_public/train.json')
valid_data = AFQMC(public_path + 'afqmc_public/dev.json')

def collote_fn(batch_samples):
    batch_sentence_1, batch_sentence_2 = [], []
    batch_label = []
    for sample in batch_samples:
        batch_sentence_1.append(sample['sentence1'])
        batch_sentence_2.append(sample['sentence2'])
        batch_label.append(int(sample['label']))
    X = tokenizer(
        batch_sentence_1, 
        batch_sentence_2, 
        padding=True, 
        truncation=True, 
        return_tensors="pt"
    )
    y = torch.tensor(batch_label)
    return X, y

train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True, collate_fn=collote_fn)
valid_dataloader= DataLoader(valid_data, batch_size=batch_size, shuffle=False, collate_fn=collote_fn)

class BertForPairwiseCLS(BertPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        self.bert = BertModel(config, add_pooling_layer=False)
        self.dropout = nn.Dropout(config.hidden_dropout_prob)
        self.classifier = nn.Linear(768, 2)
        self.post_init()
    
    def forward(self, x):
        outputs = self.bert(**x)
        cls_vectors = outputs.last_hidden_state[:, 0, :]
        cls_vectors = self.dropout(cls_vectors)
        logits = self.classifier(cls_vectors)
        return logits

config = AutoConfig.from_pretrained(checkpoint)
model = BertForPairwiseCLS.from_pretrained(checkpoint, config=config).to(device)

def train_loop(dataloader, model, loss_fn, optimizer, lr_scheduler, epoch, total_loss):
    progress_bar = tqdm(range(len(dataloader)))
    progress_bar.set_description(f'loss: {0:>7f}')
    finish_step_num = (epoch-1)*len(dataloader)
    
    model.train()
    for step, (X, y) in enumerate(dataloader, start=1):
        X, y = X.to(device), y.to(device)
        pred = model(X)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        lr_scheduler.step()

        total_loss += loss.item()
        progress_bar.set_description(f'loss: {total_loss/(finish_step_num + step):>7f}')
        progress_bar.update(1)
    return total_loss

def test_loop(dataloader, model, mode='Test'):
    assert mode in ['Valid', 'Test']
    size = len(dataloader.dataset)
    correct = 0

    model.eval()
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()

    correct /= size
    print(f"{mode} Accuracy: {(100*correct):>0.1f}%\n")
    return correct

loss_fn = nn.CrossEntropyLoss()
optimizer = AdamW(model.parameters(), lr=learning_rate)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=epoch_num*len(train_dataloader),
)

total_loss = 0.
best_acc = 0.
for t in range(epoch_num):
    print(f"Epoch {t+1}/{epoch_num}\n-------------------------------")
    total_loss = train_loop(train_dataloader, model, loss_fn, optimizer, lr_scheduler, t+1, total_loss)
    valid_acc = test_loop(valid_dataloader, model, mode='Valid')
    if valid_acc > best_acc:
        best_acc = valid_acc
        print('saving new weights...\n')
        torch.save(model.state_dict(), f'epoch_{t+1}_valid_acc_{(100*valid_acc):0.1f}_model_weights.bin')
        # 保存模型权重
print("Done!")

checkpoint = "bert-base-chinese"
config = AutoConfig.from_pretrained(checkpoint)
model = BertForPairwiseCLS.from_pretrained(checkpoint, config=config).to(device)
model.load_state_dict(torch.load('epoch_3_valid_acc_74.1_model_weights.bin'))

推荐阅读：