基于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版
下一篇：[笔记]某变频器，功能列表及参数表

云原生之运维监控实践-使用Prometheus与Grafana实现对Nginx和Nacos服务的监测
没有度量就没有改进，实际上，监控系统有以下两个客户：技术，业务。上述内容即是对技术组件的监控，方便技术方面的改进与优化。本文记录了在Docker环境下通过Prometheus和Grafana实现对Ng
阅读更多2024-11-17
GitLab 部署和配置指南
这篇文档详细介绍了GitLab部署的多个方面，包括配置内置Nginx、申请和自动续期HTTPS证书、通过FRP将内网服务映射到外部，以及在阿里云服务器上配置Nginx的反向代理。内容涵盖了FRP客户端
阅读更多2024-11-17
深度学习驱动的蛋白质设计技术与前沿实践-从基础到尖端应用
1、结构生成过程中的物理能量函数与约束2、基于Deep learning的预测模型和生成模型3、结构验证与性能评估五、RFdiffusion基于指定骨架的蛋白质结构设计核心知识点：利用用户提供的特定结
阅读更多2024-11-17
刘艳兵-DBA036-Oracle数据库中的触发器（Trigger）可以在以下哪种情况下自动执行？
刘艳兵-DBA036-Oracle数据库中的触发器（Trigger）可以在以下哪种情况下自动执行？
阅读更多2024-11-17
刘艳兵-DBA037-在ASM实例中，如下哪个参数是必须的？
刘艳兵-DBA037-在ASM实例中，如下哪个参数是必须的？
阅读更多2024-11-17
基于物联网的农业环境监测系统开发（本科毕业论文）
数据访问层通过封装MongoDB的API，提供统一的数据操作接口，确保数据的一致性和安全性。对于大量的监测数据，我们使用了时序数据库InfluxDB进行存储，InfluxDB在处理时序数据方面具有天然
阅读更多2024-11-17
大数据-226 离线数仓 - Flume 优化配置自定义拦截器拦截原理了拦截器实现 Java
前面FlumeAgent的配置使用了本地时间，可能导致数据存放的路径不正确。要解决上面的问题就需要使用自定义拦截器。Agent用于测试自定义拦截器，source => logger sink#
阅读更多2024-11-17
Flutter：key的作用原理（LocalKey ，GlobalKey）
第一段代码实现的内容：创建了3个块，随机3个颜色，每次点击按钮时，把第一个块删除。Flutter中的3棵树中，Widget树和Element树。中有这样一个方法，Flutter的增量渲染就是通过。旧的
阅读更多2024-11-17
vscode 关闭绑定元素隐式具有“any”类型这类错误
出现类型“never”上不存在属性“userName”。ts-plugin(2339) 配置该参数。在vue的项目里面，经常看到any类型的报错，真的很烦的。“noImplicitAny”: fals
阅读更多2024-11-17
Vue 3 插槽详解
默认插槽（Default Slot）用于在子组件中设置一个默认插槽内容，当父组件没有提供内容时会使用这个默认内容。默认插槽非常适合在组件内部提供基本的布局和结构。具名插槽（Named Slot）用于定
阅读更多2024-11-17