基于pytorch本地部署微调bert模型（yelp文本分类数据集）

🕗 发布于 2024-09-23 07:31 pytorch bert 分类 深度学习 python

项目介绍

本项目使用hugging face上提供的Bert模型API，基于yelp数据集，在本地部署微调Bert模型，官方的文档链接为https://huggingface.co/docs/transformers/quicktour，但是在官方介绍中出现了太多的API调用接口，无法在真正意义上做到本地微调部署，本项目致力于只通过Bert模型的接口获得Bert模型，其他包括数据集预处理、损失函数定义、模型训练以后后续模型的调试部署都在本地进行，让微调的过程清晰化和透明化。

BERT模型

BERT（Bidirectional Encoder Representations from Transformers）是谷歌于2018年发布的自然语言处理模型。其核心创新在于双向上下文理解，允许模型同时考虑上下文中的前后词，从而提升对文本含义的理解。BERT的训练过程采用了无监督学习，使用大规模的文本数据进行预训练，然后通过微调适应具体任务，如问答或情感分析。这个模型的发布极大推动了NLP领域的发展，成为许多后续模型的基础。

BERT模型的预训练过程分为两个目标任务：

将训练数据集文本中的内容按照一定的比例挖空一些单词（或文字），BERT模型通过挖空单词的上下文本内容与语义复现出该位置上应该出现的单词；
将多个句子组合成一个句子组，让BERT模型判断句子之间是否存在上下语句的关系。

yelp数据集

Yelp文本分类数据集是一个用于自然语言处理（NLP）任务的公开数据集，主要用于训练和评估文本分类模型。该数据集包含来自Yelp网站的用户评论，通常包括以下几个关键特征：

评论文本：用户对商家的评论内容，通常包含对服务、食品质量、环境等方面的评价。
星级评分：用户根据他们的体验给出的评分，通常是1到5颗星。
商家信息：评论关联的商家信息，包括商家名称、类别和位置等。

代码实现

依赖环境

基于pytorch架构，显存最好大于或者等于4GB

import torch
import torch.nn as nn
from tqdm.auto import tqdm
from statistics import mean
from torch.optim import AdamW
import matplotlib.pyplot as plt
from transformers import get_scheduler
from torch.utils.data import DataLoader
from prepare_dataset_model import bert_dataset, model_bert,get_dataset_list
from transformers import AutoModel,AutoTokenizer,AutoModelForSequenceClassification

# from datasets import load_dataset 
# 可以直接从huggingface上下载并预处理训练数据集
# 感兴趣的朋友可以自行查阅函数说明文档，本项目使用自定义的数据集预处理类与函数

prepare_dataset_model是定义在另一个脚本里的数据预处理函数，接下来先展开这一部分

数据集预处理

从官网上可以下载yelp对应的数据集，本项目选择的是csv格式的数据，使用pandas可以非常轻松的对csv格式的数据进行操作与处理

下面是放在prepare_dataset_model.py脚本中的代码

数据列表的获取

def get_dataset_list(data_path,simple_num, rate=0.8):
    data = pd.read_csv(data_path)
    data_list = []
    print('loading dataset...')
    show_bar = tqdm(range(simple_num))

    for index,item in data.iterrows():
        data_list.append({"text":item['text'], "label":item['label']})
        show_bar.update(1)
        if index==simple_num:
            break

    lenght = len(data_list)
    train_data_list = data_list[:int(lenght*rate)]
    test_data_list = data_list[int(lenght*rate):]
    return train_data_list,test_data_list

ylep数据集有几万条数据，一次性全部读出来在大多数情况下显得不现实，于是定义simple_num参数进行传入我们想要处理的数据数，rate是训练集与测试集的比例，最后返回按照比例的训练集列表和测试集列表

数据集类的定义

class bert_dataset(Dataset):
    def __init__(self, data_list, tokenizer):
        self.dataset = data_list
        self.tokenizer = tokenizer

    def __getitem__(self, idx):
        item = self.dataset[idx]
        text = item["text"]
        label = item["label"]

        inputs = self.tokenizer(text,padding="max_length",truncation=True,return_tensors='pt')
        # inputs["label"] = label
        return inputs,label
    
    def __len__(self):
        return len(self.dataset)

这一步是经典的自定义数据集操作，值得一提的是，假如直接把label字段传入inputs的字典，在微调的模型中同样也能够接受，并且在模型中可以直接返回按照交叉熵损失函数计算的loss值；也可以将label字段分开，另外定义损失函数进行计算，本项目选择的是第二种

完整代码

import torch.nn as nn
import pandas as pd
import torch.nn.functional as F
from tqdm.auto import tqdm
from torch.utils.data import Dataset

class bert_dataset(Dataset):
    def __init__(self, data_list, tokenizer):
        self.dataset = data_list
        self.tokenizer = tokenizer

    def __getitem__(self, idx):
        item = self.dataset[idx]
        text = item["text"]
        label = item["label"]

        inputs = self.tokenizer(text,padding="max_length",truncation=True,return_tensors='pt')
        # inputs["label"] = label
        return inputs,label
    
    def __len__(self):
        return len(self.dataset)

class model_bert(nn.Module):
    def __init__(self, bert):
        super(model_bert,self).__init__()
        self.bert = bert
        # self.out = nn.Linear(5,1)

    def forward(self, input_ids=None, token_type_ids=None, attention_mask=None):
        bert_out = self.bert(input_ids,token_type_ids,attention_mask)
        out = F.softmax(bert_out.logits, dim=-1)
        return out
    


def get_dataset_list(data_path,simple_num, rate=0.8):
    data = pd.read_csv(data_path)
    data_list = []
    print('loading dataset...')
    show_bar = tqdm(range(simple_num))

    for index,item in data.iterrows():
        data_list.append({"text":item['text'], "label":item['label']})
        show_bar.update(1)
        if index==simple_num:
            break

    lenght = len(data_list)
    train_data_list = data_list[:int(lenght*rate)]
    test_data_list = data_list[int(lenght*rate):]
    return train_data_list,test_data_list

if __name__ == '__main__':
    data_path = r'your data path'
    train_list,test_list = get_dataset_list(data_path,5000)
    print(f'len of trian:{len(train_list)}')
    print(f'len of test:{len(test_list)}')

这里对模型也进行了调整，在输出的最后加一个softmax激活函数，最后输出分类的值，假如采用这种方式训练，损失函数的选择也应该进行对应的改变，在后面的代码中没有使用到这个模型，读者们可以自行对比一下使用原模型以及使用调整后的模型最后的训练效果

模型搭建

具体Bert模型的搭建可以使用huggingface提供的API接口

tokenizer = AutoTokenizer.from_pretrained('google-bert/bert-base-uncased')
model = AutoModelForSequenceClassification.from_pretrained('google-bert/bert-base-uncased')

具体的函数调用仍可以参考huggingface官方的说明文档，运行上面的语句后终端会显示一些下载的进度条，模型和token会被下载到C盘的.cache缓存文件夹中，以我的电脑为例，保存路径为

C:\Users\29278\.cache\huggingface

下载完成之后，以后的每一次调用都可以从这个路径上调用（除非在huggingface上的模型有更新），假如我们想直接调用本地的模型，可以通过save_pretrained语句把模型保存到指定的路径中（详见官网介绍），再通过from_pretrained语句进行调用

如果想对Bert模型的结构进行进一步的调整，可以参考上一模块的model_bert类型的架构进行定义

model_use = model_bert(model)

损失函数，优化器和学习率优化

criterion = nn.CrossEntropyLoss()
optimizer = AdamW(model.parameters(),lr = 5e-5)
lr_scheduler = get_scheduler(name="linear",optimizer=optimizer,num_warmup_steps=0,num_training_steps=num_trainStep)

这里的学习率选择使用全连接的方式进行优化，num_trainStep定义为对每一个批次的训练之后进行学习率的调整

模型训练代码

import torch
import torch.nn as nn
from tqdm.auto import tqdm
from statistics import mean
from torch.optim import AdamW
import matplotlib.pyplot as plt
# from datasets import load_dataset
from transformers import get_scheduler
from torch.utils.data import DataLoader
from prepare_dataset_model import bert_dataset, model_bert,get_dataset_list
from transformers import AutoModel,AutoTokenizer,AutoModelForSequenceClassification

device = torch.device('cuda:0' if torch.cuda.is_available else 'cpu')
print(f'using {device}...')
epoch = 10
batch_size = 8

model_path = r"your model path".replace('\\', '/')
token_path = r"your token path".replace('\\','/')
data_path = r"your data path"
tokenizer = AutoTokenizer.from_pretrained(token_path)


model = AutoModelForSequenceClassification.from_pretrained(model_path,num_labels=5).to(device)
optimizer = AdamW(model.parameters(),lr = 5e-5)
criterion = nn.CrossEntropyLoss()

# dataset_raw = load_dataset("csv",data_files=r"your data path")
# dataset_list = dataset_raw['train']
# print(type(dataset_list))

dataset_list,dataset_list_test = get_dataset_list(data_path,10)

dataset_class = bert_dataset(dataset_list,tokenizer)
dataset_class_test = bert_dataset(dataset_list_test,tokenizer)

dataset_input = DataLoader(dataset_class,batch_size=batch_size)
dataset_input_test = DataLoader(dataset_class,batch_size=batch_size,shuffle=True)

num_trainStep = epoch*len(dataset_input)
show_num_step = epoch*(len(dataset_input)+len(dataset_input_test))
lr_scheduler = get_scheduler(name="linear",optimizer=optimizer,num_warmup_steps=0,num_training_steps=num_trainStep)

loss_list = []
correct_list = []

loss_list_test = []
correct_list_test = []

process_bar = tqdm(range(show_num_step))
for step in range(epoch):
    loss_list_everyEpoch = []
    correct_list_everyEpoch = []
    model.train()
    for token, label in dataset_input:
        token = {k_in:v_in.squeeze(1).to(device) for k_in,v_in in token.items()}
        label = label.to(device)

        output = model(**token)
        out = output.logits
        # print(out)
        # print("loss:",out.loss)

        optimizer.zero_grad()
        loss = criterion(out,label)  
        loss.backward()
        optimizer.step()
        lr_scheduler.step()
        out_class = torch.argmax(out,dim=-1)

        correct_num = (out_class==label).sum()
        correct_rate = correct_num/label.shape[0]
        loss_list_everyEpoch.append(loss.item())
        correct_list_everyEpoch.append(correct_rate.item())
        process_bar.update(1)

    loss_list.append(mean(loss_list_everyEpoch))
    correct_list.append(mean(correct_list_everyEpoch))
    # print("train correct rate=",mean(correct_list_everyEpoch))
    show_correct_rate = mean(correct_list_everyEpoch)
    tqdm.write(f"train correct rate={show_correct_rate:2f}")

    loss_list_everyEpoch_test = []
    correct_list_everyEpoch_test = []
    model.eval()
    for token_test, label_test in dataset_input_test:
        token_test = {k_in:v_in.squeeze(1).to(device) for k_in,v_in in token_test.items()}
        label_test = label_test.to(device)

        output_test = model(**token_test)
        out_test = output_test.logits
        out_class_test = torch.argmax(out_test, dim=-1)
        # print(out_test)

        loss_test = criterion(out_test,label_test)
        loss_list_everyEpoch_test.append(loss_test.item())

        correct_num_test = (out_class_test==label_test).sum()
        correct_rate_test = correct_num_test/label_test.shape[0]
        correct_list_everyEpoch_test.append(correct_rate_test.item())
        process_bar.update(1)

    loss_list_test.append(mean(loss_list_everyEpoch_test))
    correct_list_test.append(mean(correct_list_everyEpoch_test))
    # print(f"test correct={mean(correct_list_everyEpoch_test)}")
    tqdm.write(f"test correct={mean(correct_list_everyEpoch_test):2f}")
    



print("train loss list:", loss_list)
print("test loss list:", loss_list_test)
print("train correct rate:", correct_list)
print("test correct rate:", correct_list_test)

结果

上述的代码仅提供一个demo，只去抽取了数据集中的10条数据进行训练，迭代10次，目的是让读者能够较快速地进行代码调试，再以此为基础对微调做更加针对性的操作

 [06:15<00:00, 18.93s/it]train loss list: [1.7557673454284668, 1.3130085468292236, 1.1637543439865112, 1.1429853439331055, 1.0526454448699951, 1.0120376348495483, 0.9493937492370605, 0.8610967397689819, 0.8940214514732361, 0.8735412955284119]
test loss list: [1.3395963907241821, 1.1231462955474854, 1.0310029983520508, 0.9932389855384827, 0.9472938776016235, 0.9150838851928711, 0.8861185908317566, 0.8644040822982788, 0.845656156539917, 0.8328518271446228]
train correct rate: [0.25, 0.625, 0.75, 0.625, 0.75, 0.625, 1.0, 1.0, 0.75, 0.875]
test correct rate: [0.5, 0.625, 0.75, 0.875, 1.0, 1.0, 0.875, 0.875, 0.875, 0.875]
100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20/20 [06:15<00:00, 18.77s/it]

可以看到在训练集和验证集上，可以明显提现出模型的微调训练效果，微调大模型的发挥空间有很多，欢迎大家一起讨论交流~

原文地址：https://blog.csdn.net/weixin_57506268/article/details/142436511

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：53 语言模型(和之后用来训练语言模型的数据集)_by《李沐：动手学深度学习v2》pytorch版
下一篇：[笔记]某变频器，功能列表及参数表

Lesson6 vim
这是一篇关于Linux中的vim的博客
阅读更多2024-09-25
EfficientNet(2019)：基于复合缩放的自动化架构搜索高效网络！
EfficientNet 由谷歌研究人员在 2019 年提出。它是一种基于 AutoAugment、AutoML 和 MobileNet 的架构，旨在提高模型的效率和性能。EfficientNet 的
阅读更多2024-09-25
vim常用快捷键
这些是vim的常用快捷指令和命令，通过熟练掌握这些快捷键，可以大幅提高在vim中编辑文件的效率。如果你刚开始使用vim，建议从最常用的光标移动和基本编辑命令开始，逐步掌握更多高级功能。直到上班后才明白
阅读更多2024-09-25
论文翻译 | Reframing Instructional Prompts to GPTk’s Language 将教学提示重新构建为GPTk的语言
对于语言模型（LMs），哪些类型的指导提示更容易遵循？我们通过广泛的实证分析来研究这个问题，揭示了成功的教学提示的重要特征。具体来说，我们研究了几种用于手动将提示重新表述为更有效提示的重构技术。一些示
阅读更多2024-09-25
大模型prompt先关
n\n从给定的文本中，我们可以抽取以下知识图谱三元组：\n\n```json\n[\n {\"subject\": \"刘德华\", \"pre
阅读更多2024-09-25
什么是网络安全自动化以及优势与挑战
网络安全自动化是指自动预防、检测、识别和消除网络威胁的过程。我们将详细了解网络安全自动化的各种挑战和优势。
阅读更多2024-09-25
Linux 中 man手册基础与 man.vim 和 ctags的安装使用
2.在家目录的 .vimrc文件中标注、使用 man.vim 插件 (把双引号里的内容复制到该文件中): “:sourse $VIMRUNTIME/ftplugin/man.vim”3.上述操作后默
阅读更多2024-09-25
从头开始：构建一个基于C/C++的线程池
构建一个基于C/C++的线程池是并发编程的重要技术之一。线程池可以有效地管理线程资源，提高系统的并发性能和响应能力。本博客将引导读者从零开始，逐步实现一个简单而高效的线程池。我们将探索C/C++线程库
阅读更多2024-09-25
vscode提升使用体验（设置 | 插件 | 快捷键）
Chinese (Simplified) (简体中文)二、打开json文件设置。三、输入以下代码片段。
阅读更多2024-09-25
ROS2 技术及分布式介绍
ROS2 本身是一个分布式通信框架，可以很方便的实现不同设备之间的通信，ROS2所基于的中间件是DDS，当处于同一网络中时，通过DDS的域ID机制(ROS_DOMAIN_ID)可以实现分布式通信，大
阅读更多2024-09-25