中文情感分类-6ren

中文情感分类

转载作者：我是一只小鸟更新时间：2023-08-31 07:38:56

本文通过ChnSentiCorp数据集介绍了文本分类任务过程，主要使用预训练语言模型bert-base-chinese直接在测试集上进行测试，也简要介绍了模型训练流程，不过最后没有保存训练好的模型.

一.任务和数据集介绍 1.任务中文情感分类本质还是一个文本分类问题。 2.数据集本文使用ChnSentiCorp情感分类数据集，每条数据中包括一句购物评价，以及一个标识，表明这条评价是一条好评还是一条差评。被评价的商品主要是书籍、酒店、计算机配件等。一些例子如下所示:

二.模型架构基本思路是先特征抽取，然后进行下游任务。前者主要是RNN、LSTM、GRU、BERT、GPT、Transformers等模型，后者本质就是分类模型，比如全连接神经网络等.

三.实现代码 1.准备数据集 (1)使用编码工具。

                
                  def load_encode_tool(pretrained_model_name_or_path):
                  

                      
                   # 加载编码工具bert-base-chinese 
                  

                      token = BertTokenizer.from_pretrained(Path(f
                   '{pretrained_model_name_or_path}' 
                  ))
                  

                      
                   # print(token) 
                  

                      
                   return 
                   token
                  

                   if 
                   __name__ == 
                   '__main__' 
                  :
                  

                      
                   # 测试编码工具 
                  

                      pretrained_model_name_or_path = r
                   'L:\20230713_HuggingFaceModel\bert-base-chinese' 
                  

                      token = load_encode_tool(pretrained_model_name_or_path)
                  

                      
                   print 
                  (token)

输出结果如下所示:

                
                  BertTokenizer(name_or_path=
                   'L:\20230713_HuggingFaceModel\bert-base-chinese' 
                  , vocab_size=21128, model_max_length=1000000000000000019884624838656, is_fast=False, padding_side=
                   'right' 
                  , truncation_side=
                   'right' 
                  , special_tokens={
                   'unk_token' 
                  : 
                   '[UNK]' 
                  , 
                   'sep_token' 
                  : 
                   '[SEP]' 
                  , 
                   'pad_token' 
                  : 
                   '[PAD]' 
                  , 
                   'cls_token' 
                  : 
                   '[CLS]' 
                  , 
                   'mask_token' 
                  : 
                   '[MASK]' 
                  }, clean_up_tokenization_spaces=True)

其中，vocab_size=21128表示bert-base-chinese模型的字典中有21128个词，特殊token主要是UNK、SEP、PAD、CLS、MASK。需要说明的是model_max_length，定义为 self.model_max_length = model_max_length if model_max_length is not None else VERY_LARGE_INTEGER 。因为从本地加载模型，不满足如下条件，所以给model_max_length赋了一个很大的数值，如下所示:

返回值token总的数据结构如下所示：接下来测试编码工具如下所示:

                
                   if 
                   __name__ == 
                   '__main__' 
                  :
                  

                      
                   # 测试编码工具 
                  

                      pretrained_model_name_or_path = r
                   'L:\20230713_HuggingFaceModel\bert-base-chinese' 
                  

                      token = load_encode_tool(pretrained_model_name_or_path)
                  

                      out = token.batch_encode_plus(
                  

                          batch_text_or_text_pairs=[
                   '从明天起，做一个幸福的人。' 
                  , 
                   '喂马，劈柴，周游世界。' 
                  ],
                  

                          truncation=True,  
                   # 是否截断 
                  

                          padding=
                   'max_length' 
                  ,  
                   # 是否填充 
                  

                          max_length=17,  
                   # 最大长度，如果不足，那么填充，如果超过，那么截断 
                  

                          return_tensors=
                   'pt' 
                  ,  
                   # 返回的类型 
                  

                          return_length=True  
                   # 返回长度 
                  

                      )
                  

                      
                   # 查看编码输出 
                  

                      
                   for 
                   key, value 
                   in 
                   out.items():
                  

                          
                   print 
                  (key, value.shape)
                  

                          
                   # 把编码还原成文本 
                  

                          
                   print 
                  (token.decode(out[
                   'input_ids' 
                  ][0]))

输出结果如下所示:

                
                  input_ids torch.Size([2, 17])
                  

                  [CLS] 从 明 天 起 ， 做 一 个 幸 福 的 人 。 [SEP] [PAD] [PAD]
                  

                  token_type_ids torch.Size([2, 17])
                  

                  [CLS] 从 明 天 起 ， 做 一 个 幸 福 的 人 。 [SEP] [PAD] [PAD]
                  

                  length torch.Size([2])
                  

                  [CLS] 从 明 天 起 ， 做 一 个 幸 福 的 人 。 [SEP] [PAD] [PAD]
                  

                  attention_mask torch.Size([2, 17])
                  

                  [CLS] 从 明 天 起 ， 做 一 个 幸 福 的 人 。 [SEP] [PAD] [PAD]

其中，out数据结构如下所示：因此， out['input_ids'][0] 表示第一个句子， token.decode(out['input_ids'][0]) 表示对第一个句子进行解码。 input_ids 、 token_type_ids 和 attention_mask 编码结果示意图如下所示：说明：bert-base-chinese编码工具是以字为词，即把每个字都作为一个词进行处理。如果对 input_ids 、 token_type_ids 和 attention_mask 物理意义不清楚的，那么参考使用编码工具 .

(2)定义数据集。

                
                  class Dataset(torch.utils.data.Dataset):
                  

                      def __init__(self, split):
                  

                          mode_name_or_path = r
                   'L:\20230713_HuggingFaceModel\ChnSentiCorp' 
                  

                          self.dataset = load_from_disk(mode_name_or_path)[split]
                  

                  

                      def __len__(self):
                  

                          
                   return 
                   len(self.dataset)
                  

                  

                      def __getitem__(self, i):
                  

                          text = self.dataset[i][
                   'text' 
                  ]
                  

                          label = self.dataset[i][
                   'label' 
                  ]
                  

                          
                   return 
                   text, label
                  

                   if 
                   __name__ == 
                   '__main__' 
                  :
                  

                      
                   # 加载训练数据集 
                  

                      dataset = Dataset(
                   'train' 
                  )
                  

                      
                   print 
                  (len(dataset), dataset[20])

输出结果如下所示:

                
                  9600 (
                   '非常不错，服务很好，位于市中心区，交通方便，不过价格也高！' 
                  , 1)

(3)定义计算设备通常做深度学习都会有个N卡，设置CUDA如下所示:

                
                  device = 
                   'cpu' 
                  

                   if 
                   torch.cuda.is_available():
                  

                     device = 
                   'cuda'

(4)定义数据整理函数主要对输入data进行batch_encode_plus()，然后返回input_ids、attention_mask、token_type_ids和labels:

                
                   # 数据整理函数 
                  

                  def collate_fn(data):
                  

                      sents = [i[0] 
                   for 
                   i 
                   in 
                   data]
                  

                      labels = [i[1] 
                   for 
                   i 
                   in 
                   data]
                  

                      
                   # 编码 
                  

                      data = token.batch_encode_plus(batch_text_or_text_pairs=sents, truncation=True, padding=
                   'max_length' 
                  , max_length=500, return_tensors=
                   'pt' 
                  , return_length=True)
                  

                      
                   # input_ids：编码之后的数字 
                  

                      
                   # attention_mask：补零的位置是0, 其他位置是1 
                  

                      input_ids = data[
                   'input_ids' 
                  ]
                  

                      attention_mask = data[
                   'attention_mask' 
                  ]
                  

                      token_type_ids = data[
                   'token_type_ids' 
                  ]
                  

                      labels = torch.LongTensor(labels)
                  

                      
                   # 把数据移动到计算设备上 
                  

                      input_ids = input_ids.to(device)
                  

                      attention_mask = attention_mask.to(device)
                  

                      token_type_ids = token_type_ids.to(device)
                  

                      labels = labels.to(device)
                  

                      
                   return 
                   input_ids, attention_mask, token_type_ids, labels
                  

                   if 
                   __name__ == 
                   '__main__' 
                  :
                  

                      
                   # 测试编码工具 
                  

                      pretrained_model_name_or_path = r
                   'L:\20230713_HuggingFaceModel\bert-base-chinese' 
                  

                      token = load_encode_tool(pretrained_model_name_or_path)
                  

                      
                  

                      
                   # 定义计算设备 
                  

                      device = 
                   'cpu' 
                  

                      
                   if 
                   torch.cuda.is_available():
                  

                          device = 
                   'cuda' 
                  

                      
                  

                      
                   # 测试数据整理函数 
                  

                      data = [
                  

                          (
                   '你站在桥上看风景' 
                  , 1),
                  

                          (
                   '看风景的人在楼上看你' 
                  , 0),
                  

                          (
                   '明月装饰了你的窗子' 
                  , 1),
                  

                          (
                   '你装饰了别人的梦' 
                  , 0),
                  

                      ]
                  

                      input_ids, attention_mask, token_type_ids, labels = collate_fn(data)
                  

                      
                   print 
                  (input_ids.shape, attention_mask.shape, token_type_ids.shape, labels)

结果输出如下所示:

                
                  torch.Size([4, 500]) torch.Size([4, 500]) torch.Size([4, 500]) tensor([1, 0, 1, 0], device=
                   'cuda:0' 
                  )

(5)定义数据集加载器定义数据集加载器使用数据整理函数批量处理数据集中的数据如下所示:

                
                  loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=16, collate_fn=collate_fn, shuffle=True, drop_last=True)

dataset：如果数据集是train dataset，那么就是训练集数据加载器；如果数据集是test dataset，那么就是测试集数据加载器，上述定义的dataset是训练集数据加载器。
batch_size=16：每个batch包括16条数据。
collate_fn=collate_fn：使用的数据整理函数
shuffle=True：打乱各个batch间的顺序，让数据随机
drop_last=True：当剩余数据不足16条时，丢弃这些尾数

2.定义模型 (1)加载预训练模型。

                
                   # 查看数据样例 
                  

                   for 
                   i, (input_ids, attention_mask, token_type_ids, labels) 
                   in 
                   enumerate(loader):
                  

                      
                   break 
                  

                   print 
                  (input_ids.shape, attention_mask.shape, token_type_ids.shape, labels)
                  

                      
                  

                  pretrained_model_name_or_path = r
                   'L:\20230713_HuggingFaceModel\bert-base-chinese' 
                  

                  pretrained = BertModel.from_pretrained(Path(f
                   '{pretrained_model_name_or_path}' 
                  ))
                  

                   # 不训练预训练模型，不需要计算梯度 
                  

                   for 
                   param 
                   in 
                   pretrained.parameters():
                  

                      param.requires_grad_(False)
                  

                  pretrained.to(device)
                  

                  

                  out = pretrained(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
                  

                   print 
                  (out.last_hidden_state.shape)

输出结果如下所示:

                
                  torch.Size([16, 500]) torch.Size([16, 500]) torch.Size([16, 500]) tensor([1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0], device=
                   'cuda:0' 
                  ) 
                   #数据整理函数计算结果 
                  

                  torch.Size([16, 500, 768]) 
                   #16表示batch size，500表示句子包含词数，768表示向量维度

其中，out是BaseModelOutputWithPoolingAndCrossAttentions对象，包括last_hidden_state和pooler_output两个字段。数据结构如下所示:

(2)定义下游任务模型该模型是权重为768×2的全连接神经网络，本质就是把768维向量转换为2维。计算过程就是通过模型提取特征矩阵(16×500×768)，然后取第1个字[CLS]代表整个文本语义特征，用于下游分类任务等。如下所示:

                
                  class Model(torch.nn.Module):
                  

                      def __init__(self):
                  

                          super().__init__()
                  

                          self.fc = torch.nn.Linear(768, 2)
                  

                  

                      def forward(self, input_ids, attention_mask, token_type_ids):
                  

                          
                   # 使用预训练模型抽取数据特征 
                  

                          with torch.no_grad():
                  

                              out = pretrained(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
                  

                          
                   # 对抽取的特征只取第1个字的结果做分类即可 
                  

                          out = self.fc(out.last_hidden_state[:, 0])
                  

                          out = out.softmax(dim=1)
                  

                          
                   return 
                   out

3.训练和测试 (1)训练。

                
                  def train():
                  

                      
                   # 定义优化器 
                  

                      optimizer = AdamW(model.parameters(), lr=5e-4)
                  

                      
                   # 定义1oss函数 
                  

                      criterion = torch.nn.CrossEntropyLoss()
                  

                      
                   # 定义学习率调节器 
                  

                      scheduler = get_scheduler(name=
                   'linear' 
                  , num_warmup_steps=0, num_training_steps=len(loader), optimizer=optimizer)
                  

                      
                   # 将模型切换到训练模式 
                  

                      model.train()
                  

                      
                   # 按批次遍历训练集中的数据 
                  

                      
                   for 
                   i, (input_ids, attention_mask, token_type_ids, labels) 
                   in 
                   enumerate(loader):
                  

                          
                   # 模型计算 
                  

                          out = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
                  

                          
                   # 计算loss并使用梯度下降法优化模型参数 
                  

                          loss = criterion(out, labels)
                  

                          loss.backward()
                  

                          optimizer.step()
                  

                          scheduler.step()
                  

                          optimizer.zero_grad()
                  

                          
                   # 输出各项数据的情况，便于观察 
                  

                          
                   if 
                   i % 10 == 0:
                  

                              out = out.argmax(dim=1)
                  

                              accuracy = (out == labels).sum().item() / len(labels)
                  

                              lr = optimizer.state_dict()[
                   'param_groups' 
                  ][0][
                   'lr' 
                  ]
                  

                              
                   print 
                  (i, loss.item(), lr, accuracy)

(2)测试。

                
                  def 
                   test 
                  ():
                  

                      
                   # 定义测试数据集加载器 
                  

                      loader_test = torch.utils.data.DataLoader(dataset=Dataset(
                   'test' 
                  ), batch_size=32, collate_fn=collate_fn, shuffle=True, drop_last=True)
                  

                      
                   # 将下游任务模型切换到运行模式 
                  

                      model.eval()
                  

                      correct = 0
                  

                      total = 0
                  

                      
                   # 按批次遍历测试集中的数据 
                  

                      
                   for 
                   i, (input_ids, attention_mask, token_type_ids, labels) 
                   in 
                   enumerate(loader_test):
                  

                          
                   # 计算5个批次即可，不需要全部遍历 
                  

                          
                   if 
                   i == 5:
                  

                              
                   break 
                  

                          
                   print 
                  (i)
                  

                          
                   # 计算 
                  

                          with torch.no_grad():
                  

                              out = model(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
                  

                          
                   # 统计正确率 
                  

                          out = out.argmax(dim=1)
                  

                          correct += (out == labels).sum().item()
                  

                          total += len(labels)
                  

                      
                   print 
                  (correct / total)

在PyTorch中，model.train()和model.eval()是用于切换模型训练和评估模式的方法:

model.train()方法：将模型切换到训练模式，这会启用一些特定的行为，例如梯度下降、权重更新等。在训练模式下，模型会使用训练数据对模型参数进行更新，以最小化损失函数。
model.eval()方法：将模型切换到评估模式，这会禁用一些在训练模式下启用的行为，例如梯度下降、权重更新等。在评估模式下，模型通常用于对测试数据进行预测，以评估模型的性能。
param.requires_grad_(False)方法：它和model.eval都可以关闭梯度计算，但两者区别在于param.requires_grad_(False)只关闭单个参数的梯度计算，而model.eval关闭整个模型的梯度计算。

参考文献： [1]HuggingFace自然语言处理详解：基于BERT中文模型的任务实战 [2]https://huggingface.co/bert-base-chinese/tree/main 。

最后此篇关于中文情感分类的文章就讲到这里了,如果你想了解更多关于中文情感分类的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： Flink-读Kafka写Hive表

文章推荐：开源SD-Small和SD-Tiny知识蒸馏代码与权重

文章推荐： Pytest框架执行用例流程浅谈

具有混合数据类型(文本、数字、分类)的 Python scikit-learn 分类
我正在尝试使用 Pandas 和 scikit-learn 在 Python 中执行分类。我的数据集包含文本变量、数值变量和分类变量的混合。假设我的数据集如下所示: Project Cost
r - 分类/二进制数据总和的直方图
我想要一种图形化且有吸引力的方式来表示二进制数据的列总和，而不是表格格式。我似乎无法让它发挥作用，尽管有人会认为这将是一次上篮。数据看起来像这样(我尝试创建一个可重现的示例，但无法让代码填充 0 和
Django 分类、子分类和子分类
我有一个简单的类别模型: class Category(models.Model): name = models.CharField(max_length=200) slug = mo
通过给类加分来进行 Prolog 分类
我正在开发一个知识系统，当用户进入一道菜时，该系统可以返回酒。我的想法是根据用户的输入为每个葡萄酒类别添加分数，然后显示最适合的葡萄酒类别的前 3 个。例如，如果有人输入鱼，那么知识库中的所有红葡萄酒
r - 分类 - 因子水平的使用
我目前正在研究流失问题的预测模型。每当我尝试运行以下模型时，都会收到此错误:至少一个类级别不是有效的 R 变量名称。这将在生成类概率时导致错误，因为变量名称将转换为 X0、X1。请使用可用作有效 R
r - 如何根据另一个栅格网格单元值对栅格进行子集(分类)？
如何对栅格重新分类(子集)r1 (与 r2 具有相同的尺寸和范围)基于 r2 中的以下条件在给定的示例中。条件: 如果网格单元格值为 r2是 >0.5 ，保留>0.5中对应的值以及紧邻0.5个值的相
Java 分类 - 什么是最好的方法
我想知道在 java 中进行以下分类的最佳方法是什么。例如，我们有一个简单的应用程序，其分类如下: 空气 -----电机类型 -----------平面对象 -----非电机型 -----------
r - 分类/决策树和选择分割
这是一个非常基本的示例。但我正在做一些数据分析，并且不断发现自己编写非常类似的 SQL 计数查询来生成概率表。我的表被定义为值 0 表示事件未发生，而值 1 表示事件确实发生。 > sqldf(
python - 我将如何进行图像标记/分类？
假设我有一组护照图像。我正在开展一个项目，我必须识别每本护照上的姓名，并最终将该对象转换为文本。对于标签(或分类(我认为是初学者))的第一部分，每本护照上都有姓名，我该怎么做？我可以使用哪些技术/
c++ - 如何解决这个图像处理问题——分类
我有这张图片: 我想做的是在花和树之间对这张图片进行分类，这样我就可以找到图片中被树木覆盖的区域，以及被那些花覆盖的区域。我在想这可能是某种 FFT 问题，但我不确定它是如何工作的。单个花的 FFT
python - 二进制数据集的特征选择(分类)
我的数据集有 32 个分类变量和一个数值连续变量(sales_volume) 首先，我使用单热编码 (pd.get_dummies) 将分类变量转换为二进制，现在我有 1294 列，因为每一列都有多个
python - 如何改进神经网络预测、分类
我正在尝试学习一些神经网络来获得乐趣。我决定尝试从 kaggle 的数据集中对一些神奇宝贝传奇卡进行分类。我阅读了文档并遵循了机器学习掌握指南，同时阅读了媒体以尝试理解该过程。我的问题/疑问:我尝试
python - 分类:推文情感分析——步骤顺序
我目前正在进行推文情绪分析，并且有几个关于步骤的正确顺序的问题。请假设数据已经过相应的预处理和准备。所以这就是我将如何进行: 使用 train_test_split(80:20 比例)停止测试数据集。
r - 带有插入符号问题的 Text2Vec 分类
一些上下文:Working with text classification and big sparse matrices in R 我一直在研究 text2vec 的文本多类分类问题。包装和 ca
r - 分层(分类)数据到树状图
数据我有以下(简化的)数据集，我们称之为 df从现在开始: species rank value 1
Python 时间序列坐标的二值 RNN 分类
我一直在尝试创建一个 RNN。我总共有一个包含 1661 个单独“条目”的数据集，每个条目中有 158 个时间序列坐标。以下是一个条目的一小部分: 0.00000000e+00 1.9260968
machine-learning - 机器学习的回归、分类
我有一个关于机器学习的分类和回归问题。第一个问题，以下数据集 http://it.tinypic.com/view.php?pic=oh3gj7&s=8#.VIjhRDGG_lF 我们可以说，数据集是
matlab - Libsvm 分类 MATLAB
我用1~200个数据作为训练数据，201~220个作为测试数据格式如下:3 个类(类 1、类 2、类 3)和 20 个特征 2 1:100 2:96 3:88 4:94 5:96 6:94 7:72
machine-learning - 分类:添加一个新变量并计算改变类输出的概率
我有 2 个基于多个数字特征(例如 v1….v20)的输出类别(好和差)。如果 v1、v2、v3 和 v4 为“高”，则该类别为“差”。如果 v1、v2、v3 和 v4 为“低”，则该类别为“好”
python - 具有变化的先验概率的文本数据集的多类 NaiveBayes 分类
我遇到了使用朴素贝叶斯将文档分类为各种类别问题的问题。实际上我想知道 P(C) 或我们最初掌握的类别的先验概率会随着时间的推移而不断变化。例如，对于类(class) - [音乐、体育、新闻] 初始概

我是一只小鸟

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

中文情感分类