pytorch入门 - 微调huggingface大模型

在自然语言处理(NLP)领域，预训练语言模型如BERT已经成为主流。HuggingFace提供的Transformers库让我们能够方便地使用这些强大的模型。
本文将详细介绍如何使用PyTorch微调HuggingFace上的BERT模型，包括原理讲解、代码实现和逐行解释。
1. 微调原理

1.1 什么是微调(Fine-tuning)

微调是指在预训练模型的基础上，针对特定任务进行少量训练的过程。
BERT等预训练模型已经在大规模语料上学习了通用的语言表示能力，通过微调，我们可以将这些知识迁移到特定任务上。
1.2 BERT模型结构

BERT模型主要由以下部分组成：

• 嵌入层(Embedding Layer)
  
• 多层Transformer编码器
  
• 池化层(Pooler)
  

在微调时，我们通常会在BERT的输出上添加一个任务特定的分类头(Classification Head)。
1.3 神经元数量计算

在我们的模型中，分类头是一个全连接层，其神经元数量计算如下：

1. 输入维度：768 (BERT最后一层隐藏状态维度)
2. 输出维度：2 (二分类任务)
3. 参数数量 = (输入维度 × 输出维度) + 输出维度(偏置项)
4.           = (768 × 2) + 2 = 1538

复制代码

2. 代码实现

2.1 数据集处理 (finetuing_my_dataset.py)

1. from datasets import load_dataset, load_from_disk  # 导入HuggingFace的数据集加载工具
2. from torch.utils.data import Dataset  # 导入PyTorch的数据集基类
4. class MydataSet(Dataset):  # 自定义数据集类，继承自PyTorch的Dataset
5.     def __init__(self, split):  # 初始化方法，split指定数据集划分
6.         save_path = r".\cache\datasets\lansinuote\ChnSentiCorp\train"  # 数据集路径
7.         self.dataset = load_from_disk(save_path)  # 从磁盘加载数据集
8.         
9.         # 根据split参数选择数据集划分
10.         if split == "train":
11.             self.dataset = self.dataset["train"]
12.         elif split == "test":
13.             self.dataset = self.dataset["test"]
14.         elif split == "validation":
15.             self.dataset = self.dataset["validation"]
16.         else:
17.             raise ValueError("split must be one of 'train', 'test', or 'validation'")
19.     def __len__(self):  # 返回数据集大小
20.         return len(self.dataset)
22.     def __getitem__(self, idx):  # 获取单个样本
23.         return self.dataset[idx]["text"], self.dataset[idx]["label"]  # 返回文本和标签
25. if __name__ == "__main__":  # 测试代码
26.     dataset = MydataSet(split="validation")  # 创建验证集实例
27.     for i in range(50):  # 打印前50个样本
28.         print(dataset[i])
29.     print(dataset)  # 打印数据集信息
30.     print(dataset[0])  # 打印第一个样本

复制代码

2.2 模型定义 (finetuing_net.py)

1. from transformers import BertModel  # 导入BERT模型
2. import torch  # 导入PyTorch
4. # 设置设备(GPU或CPU)
5. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
7. # 加载预训练BERT模型
8. cache_dir = "./cache/bertbasechinese"  # 缓存目录
9. pretrained = BertModel.from_pretrained(
10.     "bert-base-chinese",  # 中文BERT模型
11.     cache_dir=cache_dir
12. ).to(device)  # 移动到指定设备
14. class Model(torch.nn.Module):  # 自定义模型类
15.     def __init__(self):
16.         super(Model, self).__init__()  # 调用父类初始化
17.         # 定义分类头: 768维输入, 2维输出(二分类)
18.         self.fc = torch.nn.Linear(768, 2)  
20.     def forward(self, input_ids, attention_mask=None, token_type_ids=None):
21.         # 冻结BERT参数，不计算梯度
22.         with torch.no_grad():
23.             outputs = pretrained(
24.                 input_ids=input_ids,  # 输入token IDs
25.                 attention_mask=attention_mask,  # 注意力掩码
26.                 token_type_ids=token_type_ids,  # 句子类型IDs
27.             )
28.         
29.         # 使用[CLS]标记的隐藏状态作为分类特征
30.         cls_output = outputs.last_hidden_state[:, 0]  # 形状(batch_size, 768)
31.         logits = self.fc(cls_output)  # 通过分类头
32.         out = logits.softmax(dim=-1)  # softmax归一化
33.         return out

复制代码

2.3 训练过程 (finetuing_train.py)

1. import torch
2. from finetuing_my_dataset import MydataSet
3. from torch.utils.data import DataLoader
4. from finetuing_net import Model
5. from transformers import BertTokenizer
6. from torch.optim import AdamW
8. # 设置设备
9. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
10. EPOCH = 100  # 训练轮数
12. # 加载分词器
13. token = BertTokenizer.from_pretrained(
14.     "bert-base-chinese",
15.     cache_dir="./cache/tokenizer/bert-base-chinese"
16. )
18. def collate_fn(batch):  # 数据批处理函数
19.     sentes = [item[0] for item in batch]  # 提取文本
20.     labels = [item[1] for item in batch]  # 提取标签
21.    
22.     # 使用分词器处理文本
23.     data = token.batch_encode_plus(
24.         sentes,
25.         truncation=True,  # 截断过长的文本
26.         max_length=350,  # 最大长度350
27.         padding=True,  # 自动填充
28.         return_tensors="pt",  # 返回PyTorch张量
29.         return_length=True,  # 返回长度信息
30.     )
31.    
32.     # 提取编码后的数据
33.     input_ids = data["input_ids"]
34.     attention_mask = data["attention_mask"]
35.     token_type_ids = data["token_type_ids"]
36.     labels = torch.LongTensor(labels)  # 转换标签为LongTensor
37.    
38.     return input_ids, attention_mask, token_type_ids, labels
40. # 创建训练数据集和数据加载器
41. train_dataset = MydataSet(split="train")
42. train_dataloader = DataLoader(
43.     train_dataset,
44.     batch_size=32,  # 批大小32
45.     shuffle=True,  # 打乱数据
46.     drop_last=True,  # 丢弃最后不完整的批次
47.     collate_fn=collate_fn,  # 使用自定义批处理函数
48. )
50. if __name__ == "__main__":
51.     model = Model().to(device)  # 初始化模型
52.     optimizer = AdamW(model.parameters(), lr=1e-5)  # 优化器
53.     loss_func = torch.nn.CrossEntropyLoss()  # 损失函数
54.    
55.     model.train()  # 设置为训练模式
56.     for epoch in range(EPOCH):  # 训练循环
57.         for step, (input_ids, attention_mask, token_type_ids, labels) in enumerate(train_dataloader):
58.             # 移动数据到设备
59.             input_ids = input_ids.to(device)
60.             attention_mask = attention_mask.to(device)
61.             token_type_ids = token_type_ids.to(device)
62.             labels = labels.to(device)
63.             
64.             # 前向传播
65.             outputs = model(
66.                 input_ids=input_ids,
67.                 attention_mask=attention_mask,
68.                 token_type_ids=token_type_ids,
69.             )
70.             loss = loss_func(outputs, labels)  # 计算损失
71.             
72.             # 反向传播和优化
73.             optimizer.zero_grad()
74.             loss.backward()
75.             optimizer.step()
76.             
77.             # 每5步打印训练信息
78.             if step % 5 == 0:
79.                 out = outputs.argmax(dim=1)  # 预测类别
80.                 acc = (out == labels).sum().item() / len(labels)  # 计算准确率
81.                 print(f"Epoch: {epoch + 1}/{EPOCH}, Step: {step + 1}/{len(train_dataloader)}, Loss: {loss.item():.4f}, Acc: {acc:.4f}")
82.         
83.         # 保存模型
84.         torch.save(model.state_dict(), f"./model/{epoch}finetuned_model_new.pth")
85.         print(epoch, "参数保存成功")

复制代码

2.4 测试过程 (finetuing_test.py)

1. import torch
2. from finetuing_my_dataset import MydataSet
3. from torch.utils.data import DataLoader
4. from finetuing_net import Model
5. from transformers import BertTokenizer
7. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
9. # 加载分词器
10. token = BertTokenizer.from_pretrained(
11.     "bert-base-chinese",
12.     cache_dir="./cache/tokenizer/bert-base-chinese"
13. )
15. def collate_fn(batch):  # 与训练时相同的批处理函数
16.     sentes = [item[0] for item in batch]
17.     labels = [item[1] for item in batch]
18.     data = token.batch_encode_plus(
19.         sentes,
20.         truncation=True,
21.         max_length=350,
22.         padding=True,
23.         return_tensors="pt",
24.         return_length=True,
25.     )
26.     input_ids = data["input_ids"]
27.     attention_mask = data["attention_mask"]
28.     token_type_ids = data["token_type_ids"]
29.     labels = torch.LongTensor(labels)
30.     return input_ids, attention_mask, token_type_ids, labels
32. # 创建测试数据集和数据加载器
33. train_dataset = MydataSet(split="test")
34. train_dataloader = DataLoader(
35.     train_dataset,
36.     batch_size=32,
37.     shuffle=True,
38.     drop_last=True,
39.     collate_fn=collate_fn,
40. )
42. if __name__ == "__main__":
43.     acc = 0  # 正确预测数
44.     total = 0  # 总样本数
45.     model = Model().to(device)  # 初始化模型
46.     model.load_state_dict(torch.load("./model/3finetuned_model.pth"))  # 加载训练好的模型
47.    
48.     model.eval()  # 设置为评估模式
49.    
50.     for step, (input_ids, attention_mask, token_type_ids, labels) in enumerate(train_dataloader):
51.         # 移动数据到设备
52.         input_ids = input_ids.to(device)
53.         attention_mask = attention_mask.to(device)
54.         token_type_ids = token_type_ids.to(device)
55.         labels = labels.to(device)
56.         
57.         # 前向传播(不计算梯度)
58.         outputs = model(
59.             input_ids=input_ids,
60.             attention_mask=attention_mask,
61.             token_type_ids=token_type_ids,
62.         )
63.         
64.         out = outputs.argmax(dim=1)  # 预测类别
65.         acc += (out == labels).sum().item()  # 累加正确预测数
66.         total += len(labels)  # 累加总样本数
67.    
68.     print(acc / total)  # 输出准确率

复制代码

2.5 交互式预测 (finetuing_run.py)

1. import torch
2. from finetuing_net import Model
3. from transformers import BertTokenizer
5. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
7. # 类别名称
8. names = [
9.     "负向评价",  # 类别0
10.     "正向评价",  # 类别1
11. ]
13. model = Model().to(device)  # 初始化模型
15. # 加载分词器
16. token = BertTokenizer.from_pretrained(
17.     "bert-base-chinese",
18.     cache_dir="./cache/tokenizer/bert-base-chinese"
19. )
21. def collate_fn(data):  # 单样本处理函数
22.     sentes = []
23.     sentes.append(data)  # 将输入文本加入列表
24.    
25.     # 使用分词器处理文本
26.     data = token.batch_encode_plus(
27.         sentes,
28.         truncation=True,
29.         padding="max_length",
30.         max_length=350,
31.         return_tensors="pt",
32.         return_length=True,
33.     )
34.    
35.     input_ids = data["input_ids"]
36.     attention_mask = data["attention_mask"]
37.     token_type_ids = data["token_type_ids"]
38.    
39.     return input_ids, attention_mask, token_type_ids
41. def test():
42.     model.load_state_dict(torch.load("./model/2finetuned_model.pth"))  # 加载训练好的模型
43.     model.eval()  # 设置为评估模式
44.    
45.     while True:  # 交互式循环
46.         text = input("请输入文本：")  # 获取用户输入
47.         if text == "q":  # 输入q退出
48.             print("退出测试")
49.             break
50.         
51.         # 处理输入文本
52.         input_ids, attention_mask, token_type_ids = collate_fn(text)
53.         input_ids = input_ids.to(device)
54.         attention_mask = attention_mask.to(device)
55.         token_type_ids = token_type_ids.to(device)
56.         
57.         # 预测(不计算梯度)
58.         with torch.no_grad():
59.             outputs = model(input_ids, attention_mask, token_type_ids)
60.             out = outputs.argmax(dim=1)  # 预测类别
61.             print("模型预测", names[out], "\n")  # 输出预测结果
63. if __name__ == "__main__":
64.     test()  # 启动测试

复制代码

3. 关键点解析

3.1 数据处理流程

• ​​数据集加载​​：使用HuggingFace的load_from_disk加载预处理好的数据集
  
• ​​文本编码​​：使用BertTokenizer将文本转换为模型可接受的输入格式
  
• ​​批处理​​：collate_fn函数负责将多个样本打包成一个批次
  

3.2 模型结构

• ​​预训练BERT​​：固定参数，仅作为特征提取器
  
• ​​分类头​​：可训练的全连接层，将BERT输出映射到任务特定的类别空间
  

3.3 训练策略

• ​​优化器选择​​：使用AdamW优化器，适合Transformer模型
  
• ​​学习率​​：较小的学习率(1e-5)避免破坏预训练学到的知识
  
• ​​评估指标​​：准确率和交叉熵损失
  

4. 总结

本文详细介绍了如何使用PyTorch微调HuggingFace上的BERT模型，包括：

• 数据集处理与加载
  
• 模型定义与微调策略
  
• 训练、测试和交互式预测的实现
  
• 关键代码的逐行解释
  

通过微调预训练模型，我们可以在相对较小的数据集上获得良好的性能，这是现代NLP应用中的常用技术。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！