HuggingFace上提供了很多已经训练好的模型库，如果想针对特定数据集优化，那么就需要二次训练模型，并且HuggingFace也提供了训练工具。

一.准备数据集
1.加载编码工具
加载hfl/rbt3编码工具如下所示：

def load_encode():
    # 1.加载编码工具
    # 第6章/加载tokenizer
    from transformers import AutoTokenizer
    pretrained_model_name_or_path = r'L:\20230713_HuggingFaceModel\rbt3'
    tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path)
    # 第6章/试编码句子
    result = tokenizer.batch_encode_plus(
        ['明月装饰了你的窗子', '你装饰了别人的梦'],
        truncation=True,
    )
    print(result)

输出结果如下所示：

{'input_ids': [[101, 3209, 3299, 6163, 7652, 749, 872, 4638, 4970, 2094, 102], [101, 872, 6163, 7652, 749, 1166, 782, 4638, 3457, 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]], 
'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}

2.准备数据集
ChnSentiCorp是谭松波收集整理了一个较大规模的酒店评论语料。7000多条酒店评论数据，5000多条正向评论，2000多条负向评论[3]。

def f1(data):
    # 通过编码工具将文字编码为数据
    from transformers import AutoTokenizer
    from pathlib import Path
    pretrained_model_name_or_path = r'L:\20230713_HuggingFaceModel\rbt3'
    tokenizer = AutoTokenizer.from_pretrained(Path(f'{pretrained_model_name_or_path}'))
    return tokenizer.batch_encode_plus(data['text'], truncation=True)

def f2(data):
    # 过滤太长的句子
    return [len(i) <= 512 for i in data['input_ids']]

def load_dataset_from_disk():
    # 方法1：从HuggingFace加载数据集，然后本地保存
    # from datasets import load_dataset
    # dataset = load_dataset(path='seamew/ChnSentiCorp')
    # print(dataset)
    # dataset.save_to_disk(dataset_dict_path='./data/ChnSentiCorp')

    # 方法2：从本地加载数据集
    from datasets import load_from_disk
    mode_name_or_path = r'L:\20230713_HuggingFaceModel\ChnSentiCorp'
    dataset = load_from_disk(mode_name_or_path)
    # 缩小数据规模，便于测试
    dataset['train'] = dataset['train'].shuffle().select(range(2000))
    dataset['test'] = dataset['test'].shuffle().select(range(100))

    # batched=True表示批量处理
    # batch_size=1000表示每次处理1000个样本
    # num_proc=8表示使用8个线程操作
    # remove_columns=['text']表示移除text列
    dataset = dataset.map(f1, batched=True, batch_size=1000, num_proc=8, remove_columns=['text'])

    return dataset

由于模型对输入文本的长度有限制，不能处理长度大于512词的文本，因此把长度超过512个词的句子过滤掉。过滤前的dataset为：

DatasetDict({
    train: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 2000
    })
    validation: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 1200
    })
    test: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 100
    })
})

过滤后的dataset为：

DatasetDict({
    train: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 1982
    })
    validation: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 1190
    })
    test: Dataset({
        features: ['label', 'input_ids', 'token_type_ids', 'attention_mask'],
        num_rows: 99
    })
})

二.定义模型和训练工具
1.加载预训练模型
加载预训练模型代码如下所示：

def load_pretrained_mode():
    """
    加载预训练模型
    """
    from transformers import AutoModelForSequenceClassification
    import torch
    pretrained_model_name_or_path = r'L:\20230713_HuggingFaceModel\rbt3'
    model = AutoModelForSequenceClassification.from_pretrained(pretrained_model_name_or_path, num_labels=2)
    # 统计模型参数量
    print(sum([i.nelement() for i in model.parameters()]) / 10000)

    # 模拟一批数据
    data = {
        'input_ids': torch.ones(4, 10, dtype=torch.long),
        'token_type_ids': torch.ones(4, 10, dtype=torch.long),
        'attention_mask': torch.ones(4, 10, dtype=torch.long),
        'labels': torch.ones(4, dtype=torch.long)
    }
    # 模型试算
    out = model(**data)
    print(out['loss'], out['logits'].shape)

输出结果如下所示：

3847.8338
tensor(0.3911, grad_fn=<NllLossBackward0>) torch.Size([4, 2])

（1）hfl/rbt3模型
由哈尔滨工业大学讯飞联合实验室(HFL)基于中文文本数据训练的BERT模型。
（2）model数据结构

2.定义评价函数
定义评价函数代码如下所示：

def compute_metrics(eval_pred):
    """
    定义评价函数
    """
    from datasets import load_metric
    metric = load_metric('accuracy')
    logits, labels = eval_pred
    logits = logits.argmax(axis=1)
    return metric.compute(predictions=logits, references=labels)
    
if __name__ == '__main__':
    # 定义评价函数
    # 模拟输出
    from transformers.trainer_utils import EvalPrediction
    import numpy as np
    eval_pred = EvalPrediction(
        predictions=np.array([[0, 1], [2, 3], [4, 5], [6, 7]]),
        label_ids=np.array([1, 1, 0, 1]),
    )
    accuracy = compute_metrics(eval_pred)
    print(accuracy)

输出结果如下所示：

{'accuracy': 0.75}

3.定义训练超参数
可通过TrainingArguments对象来封装超参数：

#第6章/定义训练参数
from transformers import TrainingArguments
#定义训练参数
args = TrainingArguments(
#定义临时数据保存路径
output_dir='./output_dir',
#定义测试执行的策略，可取值为no、epoch、steps
evaluation_strategy='steps',
#定义每隔多少个step执行一次测试
eval_steps=30,
#定义模型保存策略，可取值为no、epoch、steps
save_strategy='steps',
#定义每隔多少个step保存一次
save_steps=30,
#定义共训练几个轮次
num_train_epochs=1,
#定义学习率
learning_rate=1e-4,
#加入参数权重衰减，防止过拟合
weight_decay=1e-2,
#定义测试和训练时的批次大小
per_device_eval_batch_size=16,
per_device_train_batch_size=16,
#定义是否要使用GPU训练
no_CUDA=True,
)

4.定义训练器
Trainer参数包括要训练的模型、超参数对象、训练和验证数据集、评价函数，以及数据整理函数。

from transformers import Trainer
from transformers.data.data_collator import DataCollatorWithPadding
#定义训练器
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=dataset['train'],
    eval_dataset=dataset['test'],
    compute_metrics=compute_metrics,
    data_collator=DataCollatorWithPadding(tokenizer),
)

5.数据整理函数介绍
通过DataCollatorWithPadding对象把一个批次中长短不一的句子补充成统一的长度（对句子的尾部补充PAD），长度取决于这个批次中最长的句子有多长，如下所示：

def test_DataCollator(tokenizer, dataset):
    """
    数据整理函数
    """
    from transformers import DataCollatorWithPadding
    # 第6章/测试数据整理函数
    data_collator = DataCollatorWithPadding(tokenizer)
    # 获取一批数据
    data = dataset['train'][:5]
    # 输出这些句子的长度
    for i in data['input_ids']:
        print(len(i))
    # 调用数据整理函数
    data = data_collator(data)
    # 查看整理后的数据
    for k, v in data.items():
        print(k, v.shape)

if __name__ == '__main__':
    from transformers import AutoTokenizer
    from pathlib import Path
    pretrained_model_name_or_path = r'L:\20230713_HuggingFaceModel\rbt3'
    tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name_or_path=Path(f'{pretrained_model_name_or_path}'))
    # 得到dataset
    dataset = load_dataset_from_disk()
    dataset = dataset.filter(f2, batched=True, batch_size=1000, num_proc=8)
    test_DataCollator(tokenizer, dataset)

结果输出如下所示：

175
136
121
34
160
input_ids torch.Size([5, 175])
token_type_ids torch.Size([5, 175])
attention_mask torch.Size([5, 175])
labels torch.Size([5])

三.训练和测试
1.训练模型
评价和训练模型代码如下所示：

trainer.evaluate() #评价模型
trainer.train()    #训练模型

在output_dir文件夹中可以找到4个文件夹，即checkpoint-30、checkpoint-60、checkpoint-90、checkpoint-120，分别是对应步数保存的检查点，每个文件夹中都有一个PyTorch_model.bin文件，这个文件就是模型的参数。每个文件夹包括文件如下所示：

config.json
optimizer.pt
pytorch_model.bin
rng_state.pth
scheduler.pt
trainer_state.json
training_args.bin

运行结果格式如下所示：

{'eval_loss': 0.48926153779029846, 'eval_accuracy': 0.8181818181818182, 'eval_runtime': 62.1286, 'eval_samples_per_second': 1.593, 'eval_steps_per_second': 0.113, 'epoch': 0.48}

如果模型在训练过程中断了，那么可以从中间检查点继续训练，如下所示：

trainer.train(resume_from_checkpoint='./output_dir/checkpoint-90')

2.模型的保存和加载
模型的保存和加载代码如下所示：

# 手动保存模型参数
trainer.save_model(output_dir='./output_dir/save_model')
# 手动加载模型参数
import torch
model.load_state_dict(torch.load('./output_dir/save_model/PyTorch_model.bin'))

3.使用模型预测
使用模型预测代码如下所示：

# 在模型的评估模式下，模型不再对输入进行梯度计算，并且一些具有随机性的操作（如Dropout）会被固定
model.eval()
for i, data in enumerate(trainer.get_eval_dataloader()):
    data = data.to('cuda')
    out = model(**data)
    out = out['logits'].argmax(dim=1)
    for j in range(8):
        print(tokenizer.decode(data['input_ids'][j], skip_special_tokens=True))
        print('label=', data['labels'][j].item())
        print('predict=', out[j].item())
    break

结果输出如下所示：

酒 店 有 点 偏 ， （ 没 有 地 铁 站 ） ， 19 ： 30 后 就 没 有 shuttle bus 了 。 大 堂 很 小 ， 也 没 有 什 么 设 施 。 不 过 ， 房 间 很 好 ， 也 有 海 景 。
label= 1
predict= 0
哈 哈 哈 哈..... 居 然 还 可 以 继 续 评 论 啊 那 就 给 满 分 了 下 次 去 了 继 续 住 忘 记 说 了, 有 房 内 按 摸 的 服 务 的 可 惜 没 时 间 去 试 了, 下 次 去 还 会 住 的......
label= 1
predict= 0
......
也 许 这 不 算 一 个 很 好 的 理 由, 但 是 我 之 所 以 喜 欢 读 书 而 不 是 看 网 上 的 资 料 什 么 的, 就 是 喜 欢 闻 着 书 香. 这 本 书 可 能 是 印 刷 的 油 墨 不 好 还 是 什 么 原 因, 感 觉 臭 臭 的 不 好 闻. 里 面 是 一 些 关 于 中 式 英 语 的 小 趣 闻, 有 些 小 乐 趣, 但 感 觉 对 于 有 浓 重 中 式 思 维 习 惯 说 英 说 的 人 来 说 才 比 较 有 点 用 处.
label= 0
predict= 0

参考文献：
[1]https://huggingface.co/datasets/seamew/ChnSentiCorp/tree/main
[2]文本数据集的下载与各种操作：https://blog.csdn.net/Wang_Dou_Dou_/article/details/127459760
[3]ChnSentiCorp：https://github.com/SophonPlus/ChineseNlpCorpus/blob/master/datasets/ChnSentiCorp_htl_all/intro.ipynb
[4]https://github.com/ai408/nlp-daily-record/tree/main/20230625_HuggingFace自然语言处理详解