Hugging Face模子微调训练（基于BERT的中文评价感情分析）

学习视频所在

• HuggingFace教程
  

项目所在

• HuggingFaceStu
  

数据集的下载

• 下载数据集，然后举行文件调解，调解效果如下图所示
  

1. # 将数据集下载到本地
2. from datasets import load_dataset
3. # 在代码开头添加（抑制所有警告）
4. import os
5. os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
7. # 指定数据集名称和本地缓存路径
8. dataset_name = "lansinuote/ChnSentiCorp"
9. cache_dir = "data/lansinuote/ChnSentiCorp"
11. # 下载并加载数据集
12. # 下载并加载数据集（添加信任远程代码参数）
13. dataset = load_dataset(
14.     dataset_name,
15.     cache_dir=cache_dir,
16.     trust_remote_code=True  # 关键修复参数
17. )
19. print(f"数据集已下载到：{cache_dir}")
20. print("\n第一条数据样例：")
21. print(dataset["train"][0])

复制代码

• 测试：加载数据，并在终端输出
  

1. from datasets import Dataset
2. # 取出测试集
3. test_set = Dataset.from_file("./data/lansinuote/ChnSentiCorp/chn_senti_corp-test.arrow")
4. print(test_set)
5. # 查看数据
6. for data in test_set:
7.     print(data)
9. # 取出训练集
10. train_set = Dataset.from_file(".//data/lansinuote/ChnSentiCorp/chn_senti_corp-train.arrow")
11. print(train_set)
12. # 查看数据
13. for data in train_set:
14.     print(data)
15. # 取出验证集
16. validation_set = Dataset.from_file("./data/lansinuote/ChnSentiCorp/chn_senti_corp-validation.arrow")
17. print(validation_set)
18. # 查看数据
19. for data in validation_set:
20.     print(data)

复制代码

模子微调的根本概念与流程

• 微调指在预训练模子的底子上，通过进一步的训练来顺应特定的卑鄙使命。BERT模子通过预训练来学习语言的通用模式，然后通过微调来顺应特定使命，如感情分析、定名实体辨认等。微调过程中，通常冻结BERT的预训练层，只训练与卑鄙使命相干的层。
  

加载数据集

• 感情分析使命的数据通常包罗文本及其对应的感情标签。利用HuggingFace的datasets库可以轻松地加载和处置惩罚数据集。
  

1. from datasets import load_dataset
2. #加载数据集
3. dataset =load_dataset('csv'，data_files="data/chnsenticorp.csv")
4. #查看数据集信息
5. print(dataset)

复制代码

数据集格式

• Hugging Face 的 datasets 库支持多种数据集格式，如 CSV、JSON、TFRecord 等。在本案例中，利用CSV格式，CSV文件应包罗两列：一列是文本数据，另一列是感情标签。
  

数据集信息

• 加载数据集后，可以查察数据集的根本信息，如数据集巨细、字段名称等。
  

制作Dataset

• 加载数据集后，须要对其举行处置惩罚以顺应模子的输入格式。这包罗数据洗濯、格式转换等操纵。
  

1. from torch.utils.data import Dataset, DataLoader
2. from datasets import Dataset as HFDataset  # 重命名以避免冲突
4. class MyDataset(Dataset):
5.     def __init__(self, split):
6.         # 根据 split 确定 .arrow 文件路径
7.         if split == "train":
8.             data_path = "./data/train/chn_senti_corp-train.arrow"
9.         elif split == "test":
10.             data_path = "./data/test/chn_senti_corp-test.arrow"
11.         elif split == "validation":
12.             data_path = "./data/validation/chn_senti_corp-validation.arrow"
13.         else:
14.             raise ValueError("无效的数据集类型，必须是 train/test/validation")
16.         # 加载 Hugging Face Dataset
17.         self.hf_dataset = HFDataset.from_file(data_path)
19.     def __len__(self):
20.         return len(self.hf_dataset)
22.     def __getitem__(self, idx):
23.         text = self.hf_dataset[idx]["text"]
24.         label = self.hf_dataset[idx]["label"]
25.         return text, label
27. if __name__ == "__main__":
28.     # 创建 PyTorch Dataset
29.     dataset = MyDataset("train")
31.     # 使用 DataLoader 进行迭代
32.     dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
34.     for data in dataloader:
35.         print(data)

复制代码

数据集字段

• 在制作Dataset时，需界说数据集的字段。在本案例中，界说了两个字段：text（文本）和labe1（感情标签）。每个字段都须要与模子的输入和输出匹配。
  

数据集信息

• 制作Dataset后，可以通过dataset.info等方法查察其巨细、字段名称等信息，以确保数据集的精确性和完备性。
  

vocab字典操纵

词汇表

• BERT模子利用词汇表（vocab）将文本转换为模子可以明白的输入格式。词汇表包罗全部模子已知的单词及其对应的索引。确保数据会合的全部文本都能找到对应的词汇索引是至关告急的。
  

1. from transformers import BertTokenizer
2. model_name="./model/google-bert/bert-base-chinese/models--google-bert--bert-base-chinese/snapshots/c30a6ed22ab4564dc1e3b2ecbf6e766b0611a33f"
3. # 加载字典和分词工具
4. # token=BertTokenizer.from_pretrained("bert-base-chinese") # 在线方式
5. token=BertTokenizer.from_pretrained(model_name) # 使用本地方式（推荐）
6. '''
7. sents=["酒店太旧，大堂感觉像三星级水平，在郑州这样的酒店水平，绝对算不上四星水平，早餐走了两圈也没有可以吃的，太差",
8.        "已经贴完了，又给小区的妈妈买了一套，值得推荐",
9.        "屏幕大，本子薄。自带数字小键盘，比较少见，声音很好，usb接口也很多，性价比高",
10.        "酒店环境很好，就是有一点偏僻，交通不是很好，不太好打车，酒店应该想办法解决一下"]
11. '''
12. # 批量编码句子
13. '''
14. out=token.batch_encode_plus(
15.     batch_text_or_text_pairs=[sents[0],sents[1]],
16.     add_special_tokens=True,
17.     truncation=True, # 句子过长截断
18.     padding="max_length", # 一律补零到max_length长度
19.     max_length=30,
20.     return_tensors=None, # 默认返回list
21.     return_attention_mask=True, # 返回 attention_mask
22.     return_token_type_ids=False,
23.     return_special_tokens_mask=True, #特殊符号标识
24.     return_length=True, # 返回length，标识长度
25.     )
26. print(out)
27. '''
28. # 获取字典
29. # vocab=token.get_vocab()
30. # print(vocab)
31. # print("阳" in vocab)
32. # 添加新词
33. token.add_tokens(new_tokens=["阳光","大志"])
34. # 重新获取字典
35. vocab=token.get_vocab()
36. print("大志" in vocab)
37. # 添加新的特殊符号 本质键值对
38. # token.add_special_tokens({"eos_token":"[EOS]"})
39. # 编码新句子
40. res=token.encode(
41.     text="阳光照在大地上[EOS]",
42.     text_pair=None,
43.     truncation=True,
44.     padding="longest",
45.     longest=10,
46.     add_special_tokens=True,
47.     return_tensors=None
48.     )
49. print(res)
50. # 解码为源字符串
51. print(token.decode(res))

复制代码

文本转换

• 利用tokenizer将文天职割成词汇表中的单词，并转换为相应的索引l。此步调须要确保文本长度、特别字符处置惩罚等都与BERT模子的预训练设置相同等。
  

卑鄙使命模子筹划

• 在微调BERT模子之前，须要筹划一个顺应感情分析使命的卑鄙模子布局。通常包罗一个或多个全毗连层，用于将BERT输出的特性向量转换为分类效果。
  

1. # 加载预训练模型
2. from transformers import BertModel
3. import torch
5. # 定义训练设备
6. DEVICE=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
7. model_dir="./model/google-bert/bert-base-chinese/models--google-bert--bert-base-chinese/snapshots/c30a6ed22ab4564dc1e3b2ecbf6e766b0611a33f"
8. pretrained=BertModel.from_pretrained(model_dir).to(DEVICE)
9. # 定义下游任务模型（将主干网络所提取的特征进行分类）
10. class Model(torch.nn.Module):
11.     def __init__(self):
12.         super().__init__()
13.         # 上一步 最后输出全连接模型 Linear(in_features=768, out_features=768, bias=True)
14.         self.fc = torch.nn.Linear(768, 2)
15.     # 训练推理
16.     def forward(self,input_ids,attention_mask,token_type_ids):
17.         # 上游任务不参与训练 不参与反向传播，只参与前向训练
18.        with torch.no_grad():
19.            out=pretrained(input_ids=input_ids,attention_mask=attention_mask,token_type_ids=token_type_ids)
20.        # 下游任务参与训练
21.        output=self.fc(out.last_hidden_state[:0])
22.        output=output.softmax(dim=1)
23.        return output;

复制代码

模子训练与生存

数据加载

• 利用DataLoader实现批量数据加载。DataLoader主动处置惩罚数据的批处置惩罚和随机打乱，确保训l练的高效性和数据的多样性。
  

优化器

• Adamw是一种实用于BERT模子的优化器，联合了Adam和权重衰减的特点，可以大概有用地防止过拟合。
  

训练循环

• 训练循环包罗前向传播（forward pass）、丧失盘算（loss calculation）、反向传播（backward pass）、参数更新（parameter update）等步调。每个epoch 都会对整个数据集举行一次遍历，更新模子参数。通常训练过程中会跟踪丧失值的厘革，以判定模子的收敛环境。
  

1. import torch
2. from torch.optim import AdamW
4. from MyData import MyDataset
5. from torch.utils.data import DataLoader
6. from Net import Model
7. from transformers import BertTokenizer
9. # 定义训练设备
10. DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
11. EPOCHS = 100
12. BATCH_SIZE = 32
13. # 加载分词器
14. model_name = "./model/google-bert/bert-base-chinese/models--google-bert--bert-base-chinese/snapshots/c30a6ed22ab4564dc1e3b2ecbf6e766b0611a33f"
15. token = BertTokenizer.from_pretrained(model_name)
17. # 自定义数据编码处理函数
18. def collate_fn(data):
19.     sente = [i[0] for i in data]
20.     label = [i[1] for i in data]
21.     # 编码处理
22.     data = token.batch_encode_plus(
23.         batch_text_or_text_pairs=sente,
24.         truncation=True,
25.         padding='max_length',
26.         max_length=300,
27.         return_tensors='pt',
28.         return_length=True
29.     )
30.     input_ids = data['input_ids']
31.     attention_mask = data['attention_mask']
32.     token_type_ids = data['token_type_ids']
33.     labels = torch.LongTensor(label)
35.     return input_ids, attention_mask, token_type_ids, labels
37. # 创建数据集
38. train_dataset = MyDataset("train")
39. # 创建数据加载器
40. train_loader = DataLoader(
41.     dataset=train_dataset,
42.     batch_size=BATCH_SIZE,
43.     shuffle=True,
44.     drop_last=True,
45.     collate_fn=collate_fn  # 只传递函数名
46. )
48. if __name__ == '__main__':
49.     # start train
50.     print(DEVICE)
51.     model = Model().to(DEVICE)
52.     # 优化器
53.     optimizer = AdamW(model.parameters(), lr=5e-4)
54.     # loss function
55.     loss_func=torch.nn.CrossEntropyLoss()
56.     # train model
57.     model.train()
58.     for epoch in range(EPOCHS):
59.         for i,(input_ids, attention_mask, token_type_ids, labels) in enumerate(train_loader):
60.             # 将数据放到DEVICE上
61.             input_ids, attention_mask, token_type_ids, labels=input_ids.to(DEVICE), attention_mask.to(DEVICE), token_type_ids.to(DEVICE), labels.to(DEVICE)
62.             # 执行前向计算
63.             out=model(input_ids, attention_mask, token_type_ids)
64.             # print("Output shape:", out.shape)
65.             # 计算损失
66.             loss = loss_func(out, labels)
67.             # 优化模型 清空权重 反向传播 更新梯度
68.             optimizer.zero_grad()
69.             loss.backward()
70.             optimizer.step()
72.             # 每5个查看一下
73.             if i%20==0:
74.                 out=out.argmax(dim=1)
75.                 #  准确率
76.                 acc=(out==labels).sum()/len(labels)
77.                 print(epoch,i,loss.item(),acc)
78.         # 保存模型参数
79.         torch.save(model.state_dict(),f"./params/{epoch}bert.pt")
80.         print(epoch)

复制代码

终极效果评估与测试

• 在模子训练完成后，须要评估其在测试集上的性能。通常利用精确率、准确率、召回率和F1分数等指标来衡量模子的效果。
  
  
  
  • 精确率是衡量分类模子团体性能的根本指标，盘算公式为精确分类的样本数量除以总样本数量。
    
  • 准确率、召回率是分类模子的另两个告急指标，分别反映模子在正例推测上的准确性和召回本领。
    
  • F1分数是准确率和召回率的调和匀称数，通常用于不平衡数据集的评估。
    
  
  

1. import torch
2. from Net import Model
3. from transformers import BertTokenizer
4. from MyData import MyDataset
5. from torch.utils.data import DataLoader
7. DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
8. # 加载分词器
9. model_name = "./model/google-bert/bert-base-chinese/models--google-bert--bert-base-chinese/snapshots/c30a6ed22ab4564dc1e3b2ecbf6e766b0611a33f"
10. token = BertTokenizer.from_pretrained(model_name)
12. # 自定义数据编码处理函数
13. def collate_fn(data):
14.     sente = [i[0] for i in data]
15.     label = [i[1] for i in data]
16.     # 编码处理
17.     data = token.batch_encode_plus(
18.         batch_text_or_text_pairs=sente,
19.         truncation=True,
20.         padding='max_length',
21.         max_length=300,
22.         return_tensors='pt',
23.         return_length=True
24.     )
25.     input_ids = data['input_ids']
26.     attention_mask = data['attention_mask']
27.     token_type_ids = data['token_type_ids']
28.     labels = torch.LongTensor(label)
30.     return input_ids, attention_mask, token_type_ids, labels
32. # 创建数据集
33. train_dataset = MyDataset("train")
34. # 创建数据加载器
35. train_loader = DataLoader(
36.     dataset=train_dataset,
37.     batch_size=32,
38.     shuffle=True,
39.     drop_last=True,
40.     collate_fn=collate_fn  # 只传递函数名
41. )
43. if __name__ == "__main__":
44.     acc=0
45.     total=0
46.     model=Model().to(DEVICE)
47.     model.load_state_dict(torch.load("./params/1bert.pt"))
48.     model.eval() # 开启模型测试模式
49.     for i, (input_ids, attention_mask, token_type_ids, labels) in enumerate(train_loader):
50.         # 将数据放到DEVICE上
51.         input_ids, attention_mask, token_type_ids, labels = input_ids.to(DEVICE), attention_mask.to(
52.             DEVICE), token_type_ids.to(DEVICE), labels.to(DEVICE)
53.         # 执行前向计算
54.         out = model(input_ids, attention_mask, token_type_ids)
56.         out=out.argmax(dim=1)
57.         acc+=(out==labels).sum().item()
58.         total+=len(labels)
59.     print(acc/total)

复制代码

模子加载和测试

• 利用模子举行测试
  

1. import torch
2. from transformers import BertTokenizer
4. from emotionAnalysis.Net import Model
6. DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
7. print(DEVICE)
9. values=["负向评价","正向评价"]
10. model=Model().to(DEVICE)
12. # 加载分词器
13. model_name = "./model/google-bert/bert-base-chinese/models--google-bert--bert-base-chinese/snapshots/c30a6ed22ab4564dc1e3b2ecbf6e766b0611a33f"
14. token = BertTokenizer.from_pretrained(model_name)
16. # 自定义数据编码处理函数
17. def collate_fn(data):
18.     sente = [data]
19.     # 编码处理
20.     data = token.batch_encode_plus(
21.         batch_text_or_text_pairs=sente,
22.         truncation=True,
23.         padding='max_length',
24.         max_length=300,
25.         return_tensors='pt',
26.         return_length=True
27.     )
28.     input_ids = data['input_ids']
29.     attention_mask = data['attention_mask']
30.     token_type_ids = data['token_type_ids']
32.     return input_ids, attention_mask, token_type_ids
34. def test():
35.     model.load_state_dict(torch.load("./params/1bert.pt"))
36.     model.eval()
37.     while True:
38.         data=input("请输入测试数据（输入‘q’退出）:")
39.         if data=="q":
40.             print("测试结束")
41.             break
42.         input_ids, attention_mask, token_type_ids=collate_fn(data)
43.         input_ids, attention_mask, token_type_ids=input_ids.to(DEVICE), attention_mask.to(DEVICE), token_type_ids.to(DEVICE)
45.         with torch.no_grad():
46.             out=model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
47.             out=out.argmax(dim=1)
48.             print("模型判定：",values[out],"\n")
50. if __name__=="__main__":
51.     test()

复制代码

1. cuda
2. 请输入测试数据（输入‘q’退出）:酒店服务不错，环境也还比较好！特别是好像是48楼那个旋转餐厅满有特色，至少我觉得住这个酒店还满满意！
3. 模型判定： 正向评价
5. 请输入测试数据（输入‘q’退出）:东西很差
6. 模型判定： 负向评价
8. 请输入测试数据（输入‘q’退出）:东西很好，我要再买一个
9. 模型判定： 正向评价
11. 请输入测试数据（输入‘q’退出）:我真的会谢谢你
12. 模型判定： 正向评价
14. 请输入测试数据（输入‘q’退出）:真的很栓Q
15. 模型判定： 负向评价

复制代码