⌈ 传知代码 ⌋ 基于BERT的语义分析实现

news2025/1/22 19:37:17

💛前情提要💛

本文是传知代码平台中的相关前沿知识与技术的分享~

接下来我们即将进入一个全新的空间,对技术有一个全新的视角~

本文所涉及所有资源均在传知代码平台可获取

以下的内容一定会让你对AI 赋能时代有一个颠覆性的认识哦!!!

以下内容干货满满,跟上步伐吧~


📌导航小助手📌

  • 💡本章重点
  • 🍞一. 概述
  • 🍞二. 语义分类
  • 🍞三. 实现原理
  • 🍞四. 核心逻辑
  • 🍞五.实现方式&演示效果
  • 🫓总结


💡本章重点

  • 基于BERT的语义分析实现

🍞一. 概述

在之前的文章中,我们介绍了BERT模型。BERT作为一种预训练语言模型,它具有很好的兼容性,能够运用在各种下游任务中,本文的主要目的是利用数据集来对BERT进行训练,从而实现一个语义分类的模型。


🍞二. 语义分类

语义分类是自然语言处理任务中的一种,包含文本分类、情感分析

文本分类

文本分类是指给定文本a,将文本分类为n个类别中的一个或多个。常见的应用包括文本话题分类,情感分类,具体的分类方向有有二分类,多分类和多标签分类。
文本分类可以采用传统机器学习方法(贝叶斯,svm等)和深度学习方法(fastText,TextCNN等)实现。
举例而言,对于一个对话数据集,我们可以用1、2、3表示他们的话题,如家庭、学校、工作等,而文本分类的目的,则是把这些文本的话题划分到给定的三种类别中。

情感分类

情感分析是自然语言处理中常见的场景,比如商品评价等。通过情感分析,可以挖掘产品在各个维度的优劣。情感分类其实也是一种特殊的文本分类,只是他更聚焦于情感匹配词典。

举例而言,情感分类可以用0/1表示负面评价/正面评价,例子如下:

0,不好的,319房间有故臭味。要求换房说满了,我是3月去的。在路上认识了一个上海人,他说他退房前也住的319,也是一股臭味。而且这个去不掉,特别是晚上,很浓。不知道是厕所的还是窗外的。服务一般,门前有绿皮公交去莫高窟,不过敦煌宾馆也有,下次住敦煌宾馆。再也不住这个酒店了,热水要放半个小时才有。

1,不错的酒店,大堂和餐厅的环境都不错。但由于给我的是一间走廊尽头的房间,所以房型看上去有点奇怪。客厅和卧室是连在一起的,面积偏小。服务还算到位,总的来说,性价比还是不错的。

本文将以情感二分类为例,实现如何利用BERT进行语义分析。


🍞三. 实现原理

首先,基于BERT预训练模型,能将一个文本转换成向量,作为模型的输入。

在BERT预训练模型的基础上,新增一个全连接层,将输入的向量通过训练转化成一个tensor作为输出,其中这个tensor的维度则是需要分类的种类,具体的值表示每个种类的概率。例如:

[0.25,0.75] 

指代的是有0.25的概率属于第一类,有0.75的概率属于第二类,因此,理论输出结果是把该文本分为第二类。


🍞四. 核心逻辑

pre_deal.py

import csv
import random
from datasets import load_dataset

def read_file(file_path):
    csv_reader = csv.reader(open(file_path, encoding='UTF-8'))
    num = 0
    data = []
    for row in csv_reader:
        if num == 0:
            num = 1
            continue
        comment_data = [row[1], int(row[0])]
        if len(comment_data[0]) > 500:
            text=comment_data[0]
            sub_texts, start, length = [], 0, len(text)
            while start < length:
                piecedata=[text[start: start + 500], comment_data[1]]
                data.append(piecedata)
                start += 500
        else:
             data.append(comment_data)
    random.shuffle(data)
    return data

对输入的csv文件进行处理,其中我们默认csv文件的格式是[label,text],将用于训练的内容读取出来,转化为numpy格式,其中,如果遇到有些文本过长(超过模型的输入),将其截断,分为多个文本段来输入。在最后,会通过shuffle函数进行打乱。

train.py

train.py定义了几个函数,用于训练。

首先是Bertmodel类,定义了基于Bert的训练模型:

class Bertmodel(nn.Module):
    def __init__(self, output_dim, model_path):
        super(Bertmodel, self).__init__()
        # 导入bert模型
        self.bert = BertModel.from_pretrained(model_path)
        # 外接全连接层
        self.layer1 = nn.Linear(768, output_dim)

    def forward(self, tokens):
        res = self.bert(**tokens)
        res = self.layer1(res[1])
        res = res.softmax(dim=1)
        return res

该模型由Bert和一个全连接层组成,最后经过softmax激活函数。

其次是一个评估函数,用来计算模型结果的准确性

def evaluate(net, comments_data, labels_data, device, tokenizer):
    ans = 0 # 输出结果
    i = 0
    step = 8 # 每轮一次读取多少条数据
    tot = len(comments_data)
    while i <= tot:
        print(i)
        comments = comments_data[i: min(i + step, tot)]
        tokens_X = tokenizer(comments, padding=True, truncation=True, return_tensors='pt').to(device=device)

        res = net(tokens_X)  # 获得到预测结果

        y = torch.tensor(labels_data[i: min(i + step, tot)]).reshape(-1).to(device=device)

        ans += (res.argmax(axis=1) == y).sum()
        i += step

    return ans / tot

原理就是,将文本转化为tokens,输入给模型,而后利用返回的结果,计算准确性

下面展示了开始训练的主函数,在训练的过程中,进行后向传播,储存checkpoints模型

def training(net, tokenizer, loss, optimizer, train_comments, train_labels, test_comments, test_labels,
                          device, epochs):
    max_acc = 0.5  # 初始化模型最大精度为0.5

    for epoch in tqdm(range(epochs)):
        step = 8
        i, sum_loss = 0, 0
        tot=len(train_comments)
        while i < tot:
            comments = train_comments[i: min(i + step, tot)]
            tokens_X = tokenizer(comments, padding=True, truncation=True, return_tensors='pt').to(device=device)

            res = net(tokens_X)

            y = torch.tensor(train_labels[i: min(i + step, len(train_comments))]).reshape(-1).to(device=device)

            optimizer.zero_grad()  # 清空梯度
            l = loss(res, y)  # 计算损失
            l.backward()  # 后向传播
            optimizer.step()  # 更新梯度

            sum_loss += l.detach()  # 累加损失
            i += step

        train_acc = evaluate(net, train_comments, train_labels)
        test_acc = evaluate(net, test_comments, test_labels)

        print('\n--epoch', epoch + 1, '\t--loss:', sum_loss / (len(train_comments) / 8), '\t--train_acc:', train_acc,
              '\t--test_acc', test_acc)

        # 保存模型参数,并重设最大值
        if test_acc > max_acc:
            # 更新历史最大精确度
            max_acc = test_acc

            # 保存模型
            max_acc = test_acc
            torch.save({
                'epoch': epoch,
                'state_dict': net.state_dict(),
                'optimizer': optimizer.state_dict()
            }, 'model/checkpoint_net.pth')

训练结果表示如下:

--epoch 0 	--train_acc: tensor(0.6525, device='cuda:1') 	--test_acc tensor(0.6572, device='cuda:1')

  0%|          | 0/20 [00:00<?, ?it/s]
  5%|| 1/20 [01:48<34:28, 108.88s/it]
 10%|| 2/20 [03:38<32:43, 109.10s/it]
 15%|█▌        | 3/20 [05:27<30:56, 109.20s/it]
 20%|██        | 4/20 [07:15<29:02, 108.93s/it]
 25%|██▌       | 5/20 [09:06<27:23, 109.58s/it]
 30%|███       | 6/20 [10:55<25:29, 109.26s/it]
 35%|███▌      | 7/20 [12:44<23:40, 109.28s/it]
 40%|████      | 8/20 [14:33<21:51, 109.29s/it]
 45%|████▌     | 9/20 [16:23<20:04, 109.49s/it]
 50%|█████     | 10/20 [18:13<18:15, 109.59s/it]
 55%|█████▌    | 11/20 [20:03<16:27, 109.72s/it]
 60%|██████    | 12/20 [21:52<14:35, 109.45s/it]
 65%|██████▌   | 13/20 [23:41<12:45, 109.35s/it]
 70%|███████   | 14/20 [25:30<10:54, 109.14s/it]
 75%|███████▌  | 15/20 [27:19<09:05, 109.03s/it]
 80%|████████  | 16/20 [29:07<07:15, 108.84s/it]
 85%|████████▌ | 17/20 [30:56<05:26, 108.86s/it]
 90%|█████████ | 18/20 [32:44<03:37, 108.75s/it]
 95%|█████████▌| 19/20 [34:33<01:48, 108.73s/it]
100%|██████████| 20/20 [36:22<00:00, 108.71s/it]
100%|██████████| 20/20 [36:22<00:00, 109.11s/it]

--epoch 1 	--loss: tensor(1.2426, device='cuda:1') 	--train_acc: tensor(0.6759, device='cuda:1') 	--test_acc tensor(0.6789, device='cuda:1')

--epoch 2 	--loss: tensor(1.0588, device='cuda:1') 	--train_acc: tensor(0.8800, device='cuda:1') 	--test_acc tensor(0.8708, device='cuda:1')

--epoch 3 	--loss: tensor(0.8543, device='cuda:1') 	--train_acc: tensor(0.8988, device='cuda:1') 	--test_acc tensor(0.8887, device='cuda:1')

--epoch 4 	--loss: tensor(0.8208, device='cuda:1') 	--train_acc: tensor(0.9111, device='cuda:1') 	--test_acc tensor(0.8990, device='cuda:1')

--epoch 5 	--loss: tensor(0.8024, device='cuda:1') 	--train_acc: tensor(0.9206, device='cuda:1') 	--test_acc tensor(0.9028, device='cuda:1')

--epoch 6 	--loss: tensor(0.7882, device='cuda:1') 	--train_acc: tensor(0.9227, device='cuda:1') 	--test_acc tensor(0.9024, device='cuda:1')

--epoch 7 	--loss: tensor(0.7749, device='cuda:1') 	--train_acc: tensor(0.9288, device='cuda:1') 	--test_acc tensor(0.9036, device='cuda:1')

--epoch 8 	--loss: tensor(0.7632, device='cuda:1') 	--train_acc: tensor(0.9352, device='cuda:1') 	--test_acc tensor(0.9061, device='cuda:1')

--epoch 9 	--loss: tensor(0.7524, device='cuda:1') 	--train_acc: tensor(0.9421, device='cuda:1') 	--test_acc tensor(0.9090, device='cuda:1')

--epoch 10 	--loss: tensor(0.7445, device='cuda:1') 	--train_acc: tensor(0.9443, device='cuda:1') 	--test_acc tensor(0.9103, device='cuda:1')

--epoch 11 	--loss: tensor(0.7397, device='cuda:1') 	--train_acc: tensor(0.9480, device='cuda:1') 	--test_acc tensor(0.9128, device='cuda:1')

--epoch 12 	--loss: tensor(0.7321, device='cuda:1') 	--train_acc: tensor(0.9505, device='cuda:1') 	--test_acc tensor(0.9123, device='cuda:1')

--epoch 13 	--loss: tensor(0.7272, device='cuda:1') 	--train_acc: tensor(0.9533, device='cuda:1') 	--test_acc tensor(0.9140, device='cuda:1')

--epoch 14 	--loss: tensor(0.7256, device='cuda:1') 	--train_acc: tensor(0.9532, device='cuda:1') 	--test_acc tensor(0.9111, device='cuda:1')

--epoch 15 	--loss: tensor(0.7186, device='cuda:1') 	--train_acc: tensor(0.9573, device='cuda:1') 	--test_acc tensor(0.9123, device='cuda:1')

--epoch 16 	--loss: tensor(0.7135, device='cuda:1') 	--train_acc: tensor(0.9592, device='cuda:1') 	--test_acc tensor(0.9136, device='cuda:1')

--epoch 17 	--loss: tensor(0.7103, device='cuda:1') 	--train_acc: tensor(0.9601, device='cuda:1') 	--test_acc tensor(0.9128, device='cuda:1')

--epoch 18 	--loss: tensor(0.7091, device='cuda:1') 	--train_acc: tensor(0.9590, device='cuda:1') 	--test_acc tensor(0.9086, device='cuda:1')

--epoch 19 	--loss: tensor(0.7084, device='cuda:1') 	--train_acc: tensor(0.9626, device='cuda:1') 	--test_acc tensor(0.9123, device='cuda:1')

--epoch 20 	--loss: tensor(0.7038, device='cuda:1') 	--train_acc: tensor(0.9628, device='cuda:1') 	--test_acc tensor(0.9107, device='cuda:1')

最终训练结果,在训练集上达到了96.28%的准确率,在测试集上达到了91.07%的准确率

test_demo.py

这个函数提供了一个调用我们储存的checkpoint模型来进行预测的方式,将input转化为berttokens,而后输入给模型,返回输出结果。

input_text=['这里环境很好,风光美丽,下次还会再来的。']
Bert_model_path = 'xxxx'
output_path='xxxx'
device = torch.device('cpu')
checkpoint = torch.load(output_path,map_location='cpu')

model = Bertmodel(output_dim=2,model_path=Bert_model_path)
model.load_state_dict(checkpoint,False)
# print(model)
tokenizer = BertTokenizer.from_pretrained(Bert_model_path,model_max_length=512)

tokens_X = tokenizer(input_text, padding=True, truncation=True, return_tensors='pt').to(device='cpu')
model.eval()
output=model(tokens_X)
print(output)
out = torch.unsqueeze(output.argmax(dim=1), dim=1)
result = out.numpy()
print(result)
if result[0][0]==1:
    print("positive")
else:
    print("negative")

🍞五.实现方式&演示效果

训练阶段

首先找到能够拿来训练的数据,运行pre_deal.py进行预处理,而后可以在main.py修改模型的相关参数,运行main.py开始训练。

这个过程,可能会收到硬件条件的影响,推荐使用cuda进行训练。如果实在训练不了,可以直接调用附件中对应的训练好的模型来进行预测。

测试阶段

运行test_demo.py,测试输入文本的分类结果

输入: input_text=['这里环境很好,风光美丽,下次还会再来的。']
输出: tensor([[0.3191, 0.6809]], grad_fn=<SoftmaxBackward0>)
[[1]]
结果:positive

🫓总结

综上,我们基本了解了“一项全新的技术啦” 🍭 ~~

恭喜你的内功又双叒叕得到了提高!!!

感谢你们的阅读😆

后续还会继续更新💓,欢迎持续关注📌哟~

💫如果有错误❌,欢迎指正呀💫

✨如果觉得收获满满,可以点点赞👍支持一下哟~✨

【传知科技 – 了解更多新知识】

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1719079.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

江苏大信环境科技有限公司:环保领域的开拓者与引领者

2009 年&#xff0c;江苏大信环境科技有限公司在宜兴环保科技工业园成立。自创立之始&#xff0c;该公司便笃定坚守“诚信为本、以质量求生存、以创新谋发展”这一经营理念&#xff0c;全力以赴为客户构建专业的工业有机废气治理整体解决方案&#xff0c;进而成为国家高新技术企…

Java基础语法规范

语法规范 public class HelloWorld{ //类名&#xff1a; 1. 首字母要大写 2. 源文件名与类名相同// 单行注释/* 多行注释除这两个之外还有文档注释。不重要* /public static void main (String[] args){ /* 1. main()⽅法是类体中的主⽅法&#xff0c;该⽅法从{开始到}结束…

基于 Apache Doris 的实时/离线一体化架构,赋能中国联通 5G 全连接工厂解决方案

作者&#xff1a;田向阳&#xff0c;联通西部创新研究院 大数据专家 共创&#xff1a;SelectDB 技术团队 导读&#xff1a; 数据是 5G 全连接工厂的核心要素&#xff0c;为支持全方位的数据收集、存储、分析等工作的高效进行&#xff0c;联通 5G 全连接工厂从典型的 Lambda 架…

华为SSH实验

华为SSH实验 实验拓扑&#xff1a; 实验要求&#xff1a;从SSH客户端AR1采用stelnet方式登录到SSH 服务器端。 实验步骤&#xff1a; 1.完成基本配置&#xff08;略&#xff09; sys Enter system view, return user view with CtrlZ. [AR1]sys CLIENT [CLIENT]INT g0/0/0 [C…

【IB Protocal Serial--WQE】

IB Protocal Serial--WQE 1 Intro1.1 What1.2 IBA WQE 本系列文章介绍RDMA技术的具体实现–InfiniBand Protocal&#xff1b; Introduce the features, capalities,components, and elements of IBA. the principles of operation. 1 Intro 1.1 What 理解IB协议下面这三句话对…

思迈特受邀参加工信部等权威机构行业盛会,探讨AI领域前沿技术

近日&#xff0c;思迈特软件作为国产BI领域知名厂商&#xff0c;多次受邀出席行业盛会&#xff0c;与众多业内专家学者、行业精英及知名企业代表等汇聚一堂共襄盛会&#xff0c;探讨行业前沿热点研究及最新趋势&#xff0c;分享企业数字化建设创新成果与成功实践&#xff0c;共…

一文学懂Base64编码原理

前言 Base64编码与ASCII编码一样&#xff0c;也是一种编码方式。不同的是ASCII码采用7位二进制数表示&#xff08;包括大小写字母、数字、标点符号和一些不可见字符&#xff09;&#xff0c;而Base64采用6位二进制数表示&#xff08;包括大小写字母、0~9数字、和/&#xff09;…

【考试100】安全员B证《建设工程安全生产技术》单选题

​ 题库来源&#xff1a;考试100 【考试100】安全员B证《建设工程安全生产技术》单选题 1&#xff0e;在悬空部位作业时&#xff0c;操作人员应&#xff08; &#xff09; A.遵守操作规定 B.进行安全技术交底 C.戴好安全帽 D.系好安全带 【考试100答案】&#xff1a;D…

Nginx企业级负载均衡:技术详解系列(14)—— 账户认证功能

你好&#xff0c;我是赵兴晨&#xff0c;97年文科程序员。 你有没有听说过Nginx的账户认证功能&#xff1f;这可不只是一个技术问题&#xff0c;它关系到我们上网时的安全和便利。就像家里需要一把钥匙才能进们一样&#xff0c;Nginx的账户认证功能就是确保有只有授权的人才能…

C# 写一个简单的Windows Service的服务程序

项目创建及设定部分 使用VS2019创建项目&#xff0c;选择C# Service的选项 按照你喜欢的方式命名&#xff0c;我这边就默认了 添加安装服务&#xff0c;在Service1.cs[Design]中 在设计界面右击&#xff0c;选择如下的"Add Installer" 在出现的"ProjectInstall…

python爬取每日天气情况

python爬取每日天气情况 一、项目简介二、完整代码一、项目简介 本次爬取的目标数据来源于天气网,数据所在的页面如下图所示,本次任务较为简单,按照正常操作流程操作即可,即抓包分析数据接口,发送请求获取数据,解析数据并持久化存储。发送请求使用requests库,解析数据使…

jenkins 用户权限(Manage-Roles)

本次需求将DEV环境和SIT环境分开,SIT用户登录上来只能看他的SIT项目和视图 安装roles插件 进入 manage role 项目授权 用户 正则匹配你需要的项目 dev .*-dev*或者.*-dev$ sit .*-sit最后细分assign role 测试使用sit账号登录 ,视图和项目都是SIT账号的

PG 窗口函数

一&#xff0c;简介 窗口函数也叫分析函数&#xff0c;也叫OLAP函数&#xff0c;通过partition by分组&#xff0c;这里的窗口表示范围&#xff0c;&#xff0c;可以不指定PARATITION BY,会将这个表当成一个大窗口。 二&#xff0c;应用场景 &#xff08;1&#xff09;用于分…

LeeCode热题100(1)

本文纯干货&#xff0c;看不懂来打我&#xff01; 自己先去看一下第一题的题目两数之和&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 简单来说就是让你在一个数组里面找两个数&#xff0c;这两个数的和必须满足等于目标值target才行。 我认为你要是没有思路的话&a…

【R语言基础】如何更新R版本

文章目录 概要流程细节具体步骤 概要 提示&#xff1a;由于软件包的更新&#xff0c;所以需要更新R至新版本 流程细节 查看当前R版本 R.version下载更新包&#xff1a;installr install.packages("installr")library(installr)跟着向导一步步执行安装 具体步骤 …

输入3个字符串,要求将字母按由小到大顺序输出

对于将3个整数按由小到大顺序输出&#xff0c;是很容易处理的。可以按照同样的算法来处理将3个字符串按大小顺序输出。可以直接写出程序。 编写程序&#xff1a; 运行结果&#xff1a; 这个程序是很好理解的。在程序中对字符串变量用关系运算符进行比较&#xff0c;如同对数值…

树形结构-CRUD接口

先看一下效果&#xff1a;整体的效果 新增效果 --默认值是 default 修改效果 - 大致效果如上 --------------------------------------------------------------------------------------------------------------------------------- 下面讲解代码如何实现的 根据你使用…

算法简单笔记4

5月31号&#xff0c;明天决赛&#xff0c;今天脑子也是一滩浆糊&#xff0c;踏马的一道题也做不出来&#xff0c;超级难受&#xff0c;只好简单复盘一下两道之前的题目&#xff0c;看完就差不多了&#xff0c;再学也没啥用了&#xff0c;写完这两题题解我就回去打把steam绝地求…

AI大模型的生命周期:从开发到退役的全面解析

前言 人工智能大模型&#xff08;AI大模型&#xff09;是当前AI领域的一大热点&#xff0c;它们具有强大的计算能力和广泛的应用前景。本文将全面介绍AI大模型的基础知识、训练过程、使用方法和应用场景。 一、初步了解AI大模型 AI大模型&#xff0c;通常指的是参数量达到亿…

k8s——Pod进阶(资源限制和探针)

一、资源限制 1.1 资源限制的定义 当定义Pod时可以选择性地为每个容器设定所需要的资源数量。 最常见的可设定资源是CPU和内存大小&#xff0c;以及其他类型的资源。 当为Pod中的容器指定了request资源时&#xff0c;调度器就使用该信息来决定将Pod调度到哪个节点上。当还为容器…