N2-中文文本分类

最新推荐文章于 2024-10-08 11:31:23 发布
最新推荐文章于 2024-10-08 11:31:23 发布
阅读量79 收藏
点赞数
文章标签： 分类 深度学习 机器学习 nlp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fqldom/article/details/130429073
版权

一、准备工作

1.1 环境

pytorch=2.0.0,torchtext

1.2 训练数据

train.csv

1.3 加载数据

import torch
import torch.nn as nn
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
device = torch.device("cuda")
device

device(type=‘cuda’)

import pandas as pd
train_data = pd.read_csv('./data/train.csv',sep='\t',header=None)
train_data.head()
#构造数据集迭代器
def coustom_data_iter(text, labels):
    for x,y in zip(text,labels):
        yield x,y
train_iter = coustom_data_iter(train_data[0].values[:],train_data[1].values[:])

二、数据预处理

2.1 构建词典

需要安装jieba

from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
import jieba
tokenizer = jieba.lcut

def yield_tokens(data_iter):
    for text,_ in data_iter:
        yield tokenizer(text)
vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"])

vocab(['我','想','看','和平','精英','上','战神','必备','技巧','的','游戏','视频'])

[2, 10, 13, 973, 1079, 146, 7724, 7574, 7793, 1, 186, 28]

label_name = list(set(train_data[1].values[:]))
print(label_name)

[‘Calendar-Query’, ‘Video-Play’, ‘Alarm-Update’, ‘Other’, ‘Travel-Query’, ‘FilmTele-Play’, ‘Music-Play’, ‘Weather-Query’, ‘Radio-Listen’, ‘HomeAppliance-Control’, ‘Audio-Play’, ‘TVProgram-Play’]

text_pipeline = lambda x: vocab(tokenizer(x))
label_pipeline = lambda x: label_name.index(x)

print(text_pipeline('我想看和平精英上战神必备技巧的游戏视频'))
print(label_pipeline('Video-Play'))

[2, 10, 13, 973, 1079, 146, 7724, 7574, 7793, 1, 186, 28]
1

2.2 生成数据批次和迭代器

from torch.utils.data import DataLoader
def collect_batch(batch):
    label_list, text_list , offsets = [],[],[0]
    for (_text,_label) in batch:
        label_list.append(label_pipeline(_label))
        processed_text= torch.tensor(text_pipeline(_text),dtype=torch.int64)
        text_list.append(processed_text)

        offsets.append(processed_text.size(0))
    label_list = torch.tensor(label_list,dtype=torch.int64)
    text_list = torch.cat(text_list)
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
    return text_list.to(device), label_list.to(device),offsets.to(device)
dataloader = DataLoader(train_iter,batch_size=64,shuffle=False,collate_fn=collect_batch)

三、构建模型

3.1 搭建模型

class TextClassificationModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super().__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=False)
        self.fc = nn.Linear(embed_dim, num_class)
        self.init_weights()
    def init_weights(self):
        initrange = 0.5
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.fc.weight.data.uniform_(-initrange, initrange)
        self.fc.bias.data.zero_()
    def forward(self, text, offsets):
        embedded = self.embedding(text, offsets)
        return self.fc(embedded)

3.2 初始化模型

num_class =len(label_name)
vacab_size = len(vocab)
em_size  = 64
model = TextClassificationModel(vacab_size,em_size,num_class).to(device)
Epoch = 20
learning_rate = 5
batch_size = 256
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
criterion = nn.CrossEntropyLoss().to(device)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.1)

3.3 训练函数和评估函数

from tqdm import tqdm
def train(dataloader):
    model.train()  # 切换为训练模式
    total_acc, train_loss, total_count = 0, 0, 0
    par = tqdm(dataloader)
    for idx, (text,label,offsets) in enumerate(par):

        predicted_label = model(text, offsets)

        optimizer.zero_grad()                    # grad属性归零
        loss = criterion(predicted_label, label) # 计算网络输出和真实值之间的差距，label为真实值
        loss.backward()                          # 反向传播
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) # 梯度裁剪
        optimizer.step()  # 每一步自动更新

        # 记录acc与loss
        total_acc   += (predicted_label.argmax(1) == label).sum().item()
        train_loss  += loss.item()
        total_count += label.size(0)
        par.set_description('loss: %.3f | acc: %.3f' % (train_loss / (idx + 1), total_acc / total_count))

def evaluate(dataloader):
    model.eval()  # 切换为测试模式
    total_acc, train_loss, total_count = 0, 0, 0

    with torch.no_grad():
        par = tqdm(dataloader)
        for idx, (text,label,offsets) in enumerate(par):
            predicted_label = model(text, offsets)

            loss = criterion(predicted_label, label)  # 计算loss值
            # 记录测试数据
            total_acc   += (predicted_label.argmax(1) == label).sum().item()
            train_loss  += loss.item()
            total_count += label.size(0)
            par.set_description('loss: %.3f | acc: %.3f' % (train_loss / (idx + 1), total_acc / total_count))
    return total_acc/total_count, train_loss/total_count

torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) 是一个PyTorch函数，用于在训练神经网络时限制梯度的大小。这种操作被称为梯度裁剪（gradient clipping），可以防止梯度爆炸问题，从而提高神经网络的稳定性和性能。
●model.parameters() 表示模型的所有参数。对于一个神经网络，参数通常包括权重和偏置项。
●0.1 是一个指定的阈值，表示梯度的最大范数（L2范数）。如果计算出的梯度范数超过这个阈值，梯度会被缩放，使其范数等于阈值。

四、训练模型

4.1拆分数据

from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset
train_iter = coustom_data_iter(train_data[0].values[:],train_data[1].values[:])
train_dataset = to_map_style_dataset(train_iter)
train_dataset, val_dataset = random_split(train_dataset, [int(len(train_dataset)*0.8), len(train_dataset)-int(len(train_dataset)*0.8)])
train_dataloader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True,collate_fn=collect_batch)
val_dataloader = DataLoader(val_dataset,batch_size=batch_size,shuffle=True,collate_fn=collect_batch)

4.2 训练模型

total_accu = None
for epoch in range(1,Epoch + 1):
    train(train_dataloader)
    val_acc,val_loss = evaluate(val_dataloader)
    lr = optimizer.state_dict()['param_groups'][0]['lr']
    if total_accu is not None and total_accu > val_acc:
        scheduler.step()
    else:
        total_accu = val_acc
    print('epoch: %d | lr: %.4f | val loss: %.4f | val acc: %.4f' % (epoch, learning_rate, val_loss, val_acc))

loss: 1.892 | acc: 0.453: 100%|██████████| 38/38 [00:00<00:00, 73.77it/s]
loss: 1.390 | acc: 0.663: 100%|██████████| 10/10 [00:00<00:00, 86.15it/s]
epoch: 1 | lr: 5.0000 | val loss: 0.0057 | val acc: 0.6632
loss: 1.083 | acc: 0.739: 100%|██████████| 38/38 [00:00<00:00, 72.82it/s]
loss: 0.874 | acc: 0.767: 100%|██████████| 10/10 [00:00<00:00, 81.83it/s]
epoch: 2 | lr: 5.0000 | val loss: 0.0036 | val acc: 0.7669
loss: 0.734 | acc: 0.804: 100%|██████████| 38/38 [00:00<00:00, 73.65it/s]
loss: 0.668 | acc: 0.815: 100%|██████████| 10/10 [00:00<00:00, 87.53it/s]
epoch: 3 | lr: 5.0000 | val loss: 0.0028 | val acc: 0.8149
loss: 0.578 | acc: 0.839: 100%|██████████| 38/38 [00:00<00:00, 76.48it/s]
loss: 0.556 | acc: 0.840: 100%|██████████| 10/10 [00:00<00:00, 82.11it/s]
epoch: 4 | lr: 5.0000 | val loss: 0.0023 | val acc: 0.8397
loss: 0.483 | acc: 0.864: 100%|██████████| 38/38 [00:00<00:00, 79.19it/s]
loss: 0.509 | acc: 0.855: 100%|██████████| 10/10 [00:00<00:00, 88.49it/s]
epoch: 5 | lr: 5.0000 | val loss: 0.0021 | val acc: 0.8550
loss: 0.416 | acc: 0.886: 100%|██████████| 38/38 [00:00<00:00, 76.90it/s]
loss: 0.459 | acc: 0.862: 100%|██████████| 10/10 [00:00<00:00, 77.67it/s]
epoch: 6 | lr: 5.0000 | val loss: 0.0019 | val acc: 0.8624
loss: 0.365 | acc: 0.899: 100%|██████████| 38/38 [00:00<00:00, 74.76it/s]
loss: 0.433 | acc: 0.870: 100%|██████████| 10/10 [00:00<00:00, 84.41it/s]
epoch: 7 | lr: 5.0000 | val loss: 0.0018 | val acc: 0.8698
loss: 0.325 | acc: 0.906: 100%|██████████| 38/38 [00:00<00:00, 76.51it/s]
loss: 0.411 | acc: 0.876: 100%|██████████| 10/10 [00:00<00:00, 85.80it/s]
epoch: 8 | lr: 5.0000 | val loss: 0.0017 | val acc: 0.8756
loss: 0.292 | acc: 0.920: 100%|██████████| 38/38 [00:00<00:00, 75.54it/s]
loss: 0.393 | acc: 0.877: 100%|██████████| 10/10 [00:00<00:00, 79.01it/s]
epoch: 9 | lr: 5.0000 | val loss: 0.0016 | val acc: 0.8769
loss: 0.263 | acc: 0.931: 100%|██████████| 38/38 [00:00<00:00, 73.83it/s]
loss: 0.377 | acc: 0.883: 100%|██████████| 10/10 [00:00<00:00, 82.71it/s]
epoch: 10 | lr: 5.0000 | val loss: 0.0016 | val acc: 0.8835
loss: 0.238 | acc: 0.937: 100%|██████████| 38/38 [00:00<00:00, 73.25it/s]
loss: 0.372 | acc: 0.887: 100%|██████████| 10/10 [00:00<00:00, 77.38it/s]
epoch: 11 | lr: 5.0000 | val loss: 0.0015 | val acc: 0.8868
loss: 0.217 | acc: 0.943: 100%|██████████| 38/38 [00:00<00:00, 71.55it/s]
loss: 0.361 | acc: 0.888: 100%|██████████| 10/10 [00:00<00:00, 77.22it/s]
epoch: 12 | lr: 5.0000 | val loss: 0.0015 | val acc: 0.8876
loss: 0.198 | acc: 0.950: 100%|██████████| 38/38 [00:00<00:00, 68.75it/s]
loss: 0.362 | acc: 0.890: 100%|██████████| 10/10 [00:00<00:00, 75.83it/s]
epoch: 13 | lr: 5.0000 | val loss: 0.0015 | val acc: 0.8905
loss: 0.181 | acc: 0.956: 100%|██████████| 38/38 [00:00<00:00, 65.00it/s]
loss: 0.353 | acc: 0.893: 100%|██████████| 10/10 [00:00<00:00, 78.17it/s]
epoch: 14 | lr: 5.0000 | val loss: 0.0015 | val acc: 0.8930
loss: 0.165 | acc: 0.961: 100%|██████████| 38/38 [00:00<00:00, 66.87it/s]
loss: 0.345 | acc: 0.895: 100%|██████████| 10/10 [00:00<00:00, 79.08it/s]
epoch: 15 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8946
loss: 0.152 | acc: 0.965: 100%|██████████| 38/38 [00:00<00:00, 67.15it/s]
loss: 0.347 | acc: 0.894: 100%|██████████| 10/10 [00:00<00:00, 74.05it/s]
epoch: 16 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8942
loss: 0.138 | acc: 0.971: 100%|██████████| 38/38 [00:00<00:00, 67.80it/s]
loss: 0.344 | acc: 0.894: 100%|██████████| 10/10 [00:00<00:00, 75.15it/s]
epoch: 17 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8938
loss: 0.137 | acc: 0.972: 100%|██████████| 38/38 [00:00<00:00, 67.71it/s]
loss: 0.346 | acc: 0.894: 100%|██████████| 10/10 [00:00<00:00, 76.61it/s]
epoch: 18 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8938
loss: 0.137 | acc: 0.972: 100%|██████████| 38/38 [00:00<00:00, 68.83it/s]
loss: 0.340 | acc: 0.894: 100%|██████████| 10/10 [00:00<00:00, 77.02it/s]
epoch: 19 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8938
loss: 0.136 | acc: 0.972: 100%|██████████| 38/38 [00:00<00:00, 70.25it/s]
loss: 0.347 | acc: 0.894: 100%|██████████| 10/10 [00:00<00:00, 76.30it/s]
epoch: 20 | lr: 5.0000 | val loss: 0.0014 | val acc: 0.8938

4.3 测试数据

def predict(text, text_pipeline):
    with torch.no_grad():
        text = torch.tensor(text_pipeline(text))
        output = model(text, torch.tensor([0]))
        return output.argmax(1).item()

ex_text_str = "随便播放一首专辑阁楼里的佛里的歌"
#ex_text_str = "还有双鸭山到淮阴的汽车票吗13号的"

model = model.to("cpu")
print("该文本的类别是：%s" %label_name[predict(ex_text_str, text_pipeline)])

该文本的类别是：Music-Play

五、总结

这周通过调取jieba库实现对中文文本的分类，后续将学习自己建立词典进行语言文本分类。

fqldom
关注
快速文本分类（FastText）
sikh_0529的博客
09-13 1万+
深度学习神经网络在自然语言处理中表现非常优秀，但动辄几十层，上亿参数的大型网络速度慢且需要大量算力支持，限制了使用场景。FastText是Facebook开源的一款简单而高效的文本分类器，它使用浅层的神经网络实现了word2vec以及文本分类功能，效果与深层网络差不多，节约资源，且有百倍的速度提升，可谓高效的工业级解决方案。本篇将介绍Fasttext的相关概念、原理及用法。文本分类是许多应用程序的核心问题，例如垃圾邮件检测，情感分析或智能回复。
天池-新闻文本分类-task1机器学习算法（未完待续）
qq_56591814的博客
10-23 1244
一、文本挖掘原理 1 分词的基本原理   现代分词都是基于统计的分词，而统计的样本内容来自于一些标准的语料库。假如有一个句子：“小明来到荔湾区”，我们期望语料库统计后分词的结果是：“小明/来到/荔湾/区”，而不是“小明/来到/荔/湾区”。那么如何做到这一点呢？   从统计的角度，我们期望"小明/来到/荔湾/区"这个分词后句子出现的概率要比“小明/来到/荔/湾区”大。如果用数学的语言来说说，如果有一个句子SSS,它有m种分词选项如下：A11A12...A1n1A_{11}A_{12}...A_{1n_1}A1
NLP实战：中文文本分类-Pytorch实现
m0_62237233的博客
05-31 6611
model.train() # 切换为训练模式optimizer.zero_grad() # grad属性归零loss = criterion(predicted_label, label) # 计算网络输出和真实值之间的差距，label为真实值loss.backward() # 反向传播torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) # 梯度裁剪optimizer.step() # 每一步自动更新# 记录acc与loss。
N2中文文本分类项目：用transformer库中的bert实现文本分类
HaoChen的博客
05-05 759
用bert实现多分类。注意点标签投影的设计。dataset的设计等
利用TFIDF策略和朴素贝叶斯算法进行中文文本分类
chenfei0328的博客
06-14 2万+
利用TFIDF策略和朴素贝叶斯算法进行中文文本分类
365天深度学习打卡 第N2周：中文文本分类-Pytorch实现
weixin_43960370的博客
05-19 474
这里写自定义目录标题目标Before do anything :¶mount google drive by press mount button since my account has advanced protection¶导入数据构造数据集迭代器¶数据预处理¶生成数据批次和迭代器¶定义模型¶定义实例定义训练函数与评估函数¶拆分数据集并运行模型¶使用测试数据集评估模型¶ 🍨 本文为🔗365天深度学习训练营中的学习记录博客🍖 原作者：K同学啊|接辅导、项目定制 目标 中文文本的处理 Befor
NLP学习之使用pytorch搭建textCNN模型进行中文文本分类
热门推荐
持久决心的博客
03-18 3万+
最近花周末两天时间利用pytorch实现了TextCNN进行了中文文本分类，在此进行记录。 数据获取 中文数据是从https://github.com/brightmart/nlp_chinese_corpus下载的。具体是第3个，百科问答Json版，因为感觉大小适中，适合用来学习。下载下来得到两个文件：baike_qa_train.json和baike_qa_valid.json。内容如下: {...
Linux基础篇--文本处理工具
天空飘过的鱼的博客
08-05 405
第六章 文本处理工具 本章内容概要 * 各种文本工具来查看、分析、统计文本 * grep命令用法 * 正则表达式 * 扩展正则表达式 6.1 文本工具 6.1.1 抽取文本的工具 文件内容：less和cat 文件截取：head和tail 按列抽取：cut 按关键字抽取：grep 文件查看 * 文件查看命令   cat，tac，rev * ca...
朴素贝叶斯文本分类
云聪的技术错题集
08-24 1096
基础知识 1.多项式定理 (x1+x2+...+xr)n=∑(n1,...,nr):n1+...+nr=n(nn1,n2...nr)xn11xn22...xnrr(x_1 + x_2 + ... + x_r)^n = \sum_{(n_1,...,n_r):n_1+...+n_r=n}(_{n_1,n_2...n_r}^n)x_1^{n_1}x_2^{n_2}...x_r^{n_r}
基于BERT的超长文本分类模型
valleria的博客
04-11 2万+
基于BERT的超长文本分类模型0.Abstract1.任务介绍数据集评估方法测试集 0.Abstract 本文实现了一个基于BERT+LSTM实现超长文本分类的模型, 评估方法使用准确率和F1 Score. 项目代码github地址: 1.任务介绍 用BERT做文本分类是一个比较常见的项目. 但是众所周知BERT对于文本输入长度有限制. 对于超长文本的处理, 最简单暴力无脑高效的办法是直接截断, ...
[Python从零到壹] 十四.机器学习之分类算法五万字总结全网首发（决策树、KNN、SVM、分类对比实验）
杨秀璋的专栏
07-09 2万+
分类（Classification）属于有监督学习（Supervised Learning）中的一类，它是数据挖掘、机器学习和数据科学中一个重要的研究领域。分类模型类似于人类学习的方式，通过对历史数据或训练集的学习得到一个目标函数，再用该目标函数预测新数据集的未知属性。本章主要讲述分类算法基础概念，并结合决策树、KNN、SVM分类算法案例分析各类数据集，从而让读者学会使用Python分类算法分析自己的数据集，研究自己领域的知识，从而创造价值。 19.1 分类 19.1.1 分类模型 与前面讲述的聚类模型类似
基于LSTM的中文多分类情感分析
monkey-jie的博客
10-08 1万+
趁着国庆假期，玩了一下深度学习（主要是LSTM这个网络），顺便做了一个中文多分类的情感分析。中文情感分析相对英文来说，难度太大，所以最后分析的结果，准确度也不是太高，但基本还是没啥问题的。 数据 我的数据是来自github的一个项目：ChineseNlpCorpus 里面收集了蛮多用于自然语言处理的中文数据集/语料。 下载地址： 百度网盘 数据概览： 36 万多条，带情感标注 新浪微博，包含...
昆虫分类与检测系统源码分享
最新发布
weixin_qunmasj的博客
10-08 1330
数据集信息展示在昆虫分类与检测的研究领域，数据集的构建与应用至关重要。本项目采用的数据集名为“Bug Gan”，其设计旨在为改进YOLOv8模型提供丰富的训练素材，以实现更高效的昆虫识别与分类。该数据集包含29个不同的昆虫类别，涵盖了广泛的生物多样性，能够有效支持深度学习模型在复杂环境中的学习与推理。
昆虫分类与检测系统源码分享[一条龙教学YOLOV8标注好的数据集一键训练_70+全套改进创新点发刊_Web前端展示]
qunshankeji的博客
10-08 1262
数据集信息展示在昆虫分类与检测的研究领域，数据集的构建与应用至关重要。本项目采用的数据集名为“Bug Gan”，其设计旨在为改进YOLOv8模型提供丰富的训练素材，以实现更高效的昆虫识别与分类。该数据集包含29个不同的昆虫类别，涵盖了广泛的生物多样性，能够有效支持深度学习模型在复杂环境中的学习与推理。
SVM及其实践2 --- 对典型数据集的多分类实践
xhblair的博客
10-06 948
本文承接本系列第一篇博文[1]的内容，基于SVM对两个比较典型且简单(不需要我们做太多的数据预处理工作)的公开数据集进行了分类实践。至少从流程上跑通了关于SVM实践的整个过程，分类的结果基本符合预期，不过还需要进一步优化超参数以提高模型的准确率。
sklearn机器学习实战——支持向量机四种核函数分类任务全过程（附完整代码和结果图）
m0_59197405的博客
10-06 1286
在机器学习分类任务中，支持向量机（SVM, Support Vector Machine）是一种非常强大的算法。SVM模型通过找到决策边界（超平面），以最大化类别之间的间隔（margin）来进行分类。本文将探讨如何使用四种核函数的支持向量机实现分类任务，包括数据预处理、模型训练、交叉验证、性能评估和可视化的完整流程。附完整代码和结果图
android + tflite 分类APP开发-1
model2005的专栏
10-05 440
自己数据集训练tflite模型
2024最新分别用sklearn和NumPy设计k-近邻法对鸢尾花数据集进行分类（包含详细注解与可视化结果）
m0_73811793的博客
10-08 330
【代码】2024最新分别用sklearn和NumPy设计k-近邻法对鸢尾花数据集进行分类（包含详细注解）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值