第21周：中文文本分类-Pytorch实现

前言

一、前期准备

[1.1 数据示例](#1.1 数据示例)

[1.2 文本分类的流程图](#1.2 文本分类的流程图)

[1.3 导入所需库](#1.3 导入所需库)

[1.4 加载数据](#1.4 加载数据)

二、数据预处理

[2.1 构建词典](#2.1 构建词典)

[2.2 生成数据批次和迭代器](#2.2 生成数据批次和迭代器)

三、模型构建

[3.1 搭建模型](#3.1 搭建模型)

[3.2 初始化模型和超参数定义](#3.2 初始化模型和超参数定义)

[3.3 训练函数与评估函数定义](#3.3 训练函数与评估函数定义)

四、训练模型

[4.1 拆分数据集](#4.1 拆分数据集)

[4.2 正式训练](#4.2 正式训练)

[4.3 测试指定数据](#4.3 测试指定数据)

总结

前言

🍨 本文为[🔗365天深度学习训练营]中的学习记录博客

🍖 原作者：[K同学啊]

说在前面

本周任务：使用Pytorch实现中文文本分类（主要代码和上周基本一致），采用读取本地中文数据文件进行分类；根据文本内容(第一列)预测文本标签（第2列）

进阶任务：构建更复杂的网络模型将准确率提升至91%

我的环境：Python3.8、Pycharm2020、torch1.12.1+cu113

数据来源：[K同学啊]

一、前期准备

1.1 数据示例

数据集以CVS的格式保存在本地

1.2 文本分类的流程图

文本分类的步骤如上图所示：

语料库读取数据
经过文本清洗
分词处理（jieba分词）
文本向量化
建模

1.3 导入所需库

代码如下：

python 复制代码

import torch
import os,PIL,pathlib,warnings
from torchtext.vocab import build_vocab_from_iterator
from torch.utils.data import DataLoader
from torch import nn
import time
import pandas as pd
import jieba

warnings.filterwarnings("ignore")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

特别地需要注意torchtext、jieba库的安装，详细安装需求可见torchtext、jieba安装

1.4 加载数据

代码如下：

python 复制代码

#1.4 加载自定义中文数据
train_data = pd.read_csv('./train.csv', sep='\t', header=None)
print(train_data.head())
# 构造数据集迭代器
def coustom_data_iter(texts, labels):
    for x, y in zip(texts, labels):
        yield x, y
train_iter = coustom_data_iter(train_data[0].values[:], train_data[1].values[:])

打印输出如下：

二、数据预处理

2.1 构建词典

lambda表达式的语法为：lambda arguments: expression

arguments：函数的参数，可以有多个，用逗号分隔
expression：一个表达式，定义了函数的返回值

text_pipeline函数：将原始文本数据转换为整数列表，使用了之前构建的vocab词表和tokenizer分词器函数，具体来说，它接受一个字符串x作为输入，首先使用tokenizer将其分词，然后将每个词在vocab词表的索引放入一个列表中返回

label_pipeline函数：将原始标签数据转换为整数，它接受一个字符串x作为输入，并使用label_name.index(x)方法获取x在label_name列表中的索引作为输出

tokenizer = jieba.lcut。jieba是python中的中文分词第三方库，可以将中文的文本通过分词获得单个词语，返回类型为列表类型。jieba分词共有三种模式：精确模式、全模式、搜索引擎模式。

精确模式语法：jieba.lcut(字符串,cut_all=False)，默认时为cut_all=False,表示为精确模型。精确模式是把文章词语精确的分开，并且不存在冗余词语，切分后词语总词数与文章总词数相同。
全模式语法：ieba.lcut(字符串,cut_all=True)，其中cut_all=True表示采用全模型进行分词。全模式会把文章中有可能的词语都扫描出来，有冗余，即在文本中从不同的角度分词，变成不同的词语。
搜索引擎模式：在精确模式的基础上，对长词语再次切分。

代码如下（示例）：

python 复制代码

##二、数据预处理
#2.1 构建词典
#中文分词
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(['我', '想', '看', '和平', '精英', '上', '战神', '必备', '技巧', '的', '游戏', '视频'])
label_name = list(set(train_data[1].values[:]))
print(label_name)

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

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

打印输出如下：

Building prefix dict from the default dictionary ...

Loading model from cache C:\Users\XiaoMa\AppData\Local\Temp\jieba.cache

Loading model cost 0.519 seconds.

Prefix dict has been built successfully.

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

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

2

2.2 生成数据批次和迭代器

代码如下（示例）：

python 复制代码

#2.2 生成数据批次和迭代器
def collate_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)  # 返回维度dim中输入元素的累计和
    return text_list.to(device), label_list.to(device), offsets.to(device)


# 数据加载器
dataloader = DataLoader(train_iter, batch_size=8, shuffle=False, collate_fn=collate_batch)

三、模型构建

3.1 搭建模型

代码如下：

python 复制代码

##三、模型构建
#3.1 搭建模型
class TextClassificationModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super(TextClassificationModel, self).__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)

self.embedding.weight.data.uniform_(-initrange, initrange)是在PyTorch框架下用于初始化神经网络的词嵌入层(embedding layer)权重的一种方法，这里使用了均匀分布的随机值来初始化权重，具体来说，其作用如下：

self.embedding：这是神经网络的词嵌入层(embedding layer)，其嵌入层的作用是将离散的单词表示（通常为整数索引）映射为固定大小的连续向量，这些向量捕捉了单词之间的语义关系，并作为网络的输入
self.embedding.weight：这是词嵌入层的权重矩阵，它的形状为(vocab_size,embedding_dim)，其中vocab_size是词汇表的大小，embedding_dim是嵌入向量的维度
self.embedding.weight.data：这是权重矩阵的数据部分，可以直接操作其底层的张量
.uniform_(-initrange, initrange)：这是一个原地操作，用于将权重矩阵的值用一个均匀分布进行初始化，均匀分布的范围为[-initrange,initrange]，其中initrange是一个正数

这种方式初始化词嵌入层的权重，可以使得模型在训练开始时具有一定的随机性，有助于避免梯度消失或梯度爆炸等问题，在训练过程中，这些权重将通过优化算法不断更新，以捕捉到更好的单词表示

3.2 初始化模型

代码如下：

python 复制代码

#3.2 初始化模型和超参数定义
num_class = len(label_name)
vocab_size = len(vocab)
em_size = 64
model = TextClassificationModel(vocab_size, em_size, num_class).to(device)

3.3 训练函数与评估函数定义

代码如下：

python 复制代码

# 定义训练与评估函数
def train(dataloader):
    model.train()  # 切换为训练模式
    total_acc, train_loss, total_count = 0, 0, 0
    log_interval = 50
    start_time = time.time()
    for idx, (text, label, offsets) in enumerate(dataloader):
        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)
        if idx % log_interval == 0 and idx > 0:
            elapsed = time.time() - start_time
            print('|epoch{:d}|{:4d}/{:4d} batches|train_acc{:4.3f} train_loss{:4.5f}'.format(epoch,idx,len(dataloader),
                                                                                             total_acc / total_count, train_loss / total_count))
            total_acc, train_loss, total_count = 0, 0, 0
            start_time = time.time()


def evaluate(dataloader):
    model.eval()  # 切换为测试模式
    total_acc, train_loss, total_count = 0, 0, 0
    with torch.no_grad():
        for idx, (text, label, offsets) in enumerate(dataloader):
            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)

    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范数)，如果计算出的梯度范数超过这个阈值，梯度会被缩放，使其范数等于阈值

梯度裁剪的主要目的是防止梯度爆炸。梯度爆炸通常发生在训练深度神经网络时，尤其在处理长序列数据的循环神经网络(RNN)中，当梯度爆炸时，参数更新可能会变得非常大，导致模型无法收敛或出现数值不稳定，通过限制梯度的大小，梯度裁剪有助于解决这些问题，使模型训练变得更加稳定。

四、训练模型

4.1 拆分数据集和超参数定义

代码如下：

python 复制代码

##四、训练模型
#4.1 拆分数据集并运行模型
from torch.utils.data.dataset   import random_split
from torchtext.data.functional  import to_map_style_dataset

# 超参数设定
EPOCHS = 10  # epoch
LR = 5  # learningRate
BATCH_SIZE = 64  # batch size for training

# 设置损失函数、选择优化器、设置学习率调整函数
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=LR)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.1)
total_accu = None

# 构建数据集
train_iter = coustom_data_iter(train_data[0].values[:], train_data[1].values[:])
train_dataset = to_map_style_dataset(train_iter)
split_train_, split_valid_ = random_split(train_dataset,
                                          [int(len(train_dataset) * 0.8), int(len(train_dataset) * 0.2)])

train_dataloader = DataLoader(split_train_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch)
valid_dataloader = DataLoader(split_valid_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch)

torchtext.data.functional.to_map_style_dataset函数的作用是将一个迭代式的数据集(Iterable-style dataset)转换为映射式的数据集（Map-style dataset）。这个转换使得我们可以通过索引更方便访问数据集中的元素

在PyTorch中，数据集可以分为两种类型：Iterable-style和Map-style，Iterable-style数据集实现了__iter__()方法，可以迭代访问数据集中的元素，但不支持通过索引访问，而Map-style数据集实现了__getitem__()和__len__()方法，可以直接通过索引访问特定元素，并能获取数据集的大小、

TorchText是Pytorch的一个扩展库，专注于处理文本数据，torchtext.data.functional中的to_map_style_dataset函数可以帮助我们将一个Iterable-style数据集转换为一个易于操作的Map-style数据集，这样就可以通过索引直接访问数据集中的特定样本，从而简化了训练、验证和测试过程中的数据处理。

4.2 正式训练

代码如下：

python 复制代码

#4.2 正式训练

for epoch in range(1, EPOCHS + 1):
    epoch_start_time = time.time()
    train(train_dataloader)
    val_acc, val_loss = evaluate(valid_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('-' * 69)
    print('| epoch {:d} | time:{:4.2f}s |'
          ' valid_acc {:4.3f} valid_loss {:4.3f} | lr {:4.6f}'.format(epoch, time.time() - epoch_start_time,
                                                                                       val_acc, val_loss,lr))
    print('-' * 69)

test_acc, test_loss = evaluate(valid_dataloader)
print('模型准确率为：{:5.4f}'.format(test_acc))

运行过程打印如下：

|epoch1| 50/ 152 batches|train_acc0.417 train_loss0.03058

|epoch1| 100/ 152 batches|train_acc0.678 train_loss0.01965

|epoch1| 150/ 152 batches|train_acc0.767 train_loss0.01359

| epoch 1 | time:5.01s | valid_acc 0.778 valid_loss 0.013 | lr 5.000000

|epoch2| 50/ 152 batches|train_acc0.820 train_loss0.01029

|epoch2| 100/ 152 batches|train_acc0.835 train_loss0.00944

|epoch2| 150/ 152 batches|train_acc0.840 train_loss0.00864

| epoch 2 | time:0.84s | valid_acc 0.844 valid_loss 0.009 | lr 5.000000

|epoch3| 50/ 152 batches|train_acc0.879 train_loss0.00683

|epoch3| 100/ 152 batches|train_acc0.882 train_loss0.00661

|epoch3| 150/ 152 batches|train_acc0.884 train_loss0.00608

| epoch 3 | time:0.94s | valid_acc 0.867 valid_loss 0.007 | lr 5.000000

|epoch4| 50/ 152 batches|train_acc0.907 train_loss0.00519

|epoch4| 100/ 152 batches|train_acc0.917 train_loss0.00473

|epoch4| 150/ 152 batches|train_acc0.914 train_loss0.00480

| epoch 4 | time:0.98s | valid_acc 0.878 valid_loss 0.007 | lr 5.000000

|epoch5| 50/ 152 batches|train_acc0.932 train_loss0.00382

|epoch5| 100/ 152 batches|train_acc0.933 train_loss0.00392

|epoch5| 150/ 152 batches|train_acc0.933 train_loss0.00375

| epoch 5 | time:0.97s | valid_acc 0.888 valid_loss 0.006 | lr 5.000000

|epoch6| 50/ 152 batches|train_acc0.950 train_loss0.00292

|epoch6| 100/ 152 batches|train_acc0.943 train_loss0.00337

|epoch6| 150/ 152 batches|train_acc0.953 train_loss0.00281

| epoch 6 | time:1.00s | valid_acc 0.886 valid_loss 0.006 | lr 5.000000

|epoch7| 50/ 152 batches|train_acc0.963 train_loss0.00233

|epoch7| 100/ 152 batches|train_acc0.960 train_loss0.00251

|epoch7| 150/ 152 batches|train_acc0.965 train_loss0.00222

| epoch 7 | time:0.87s | valid_acc 0.893 valid_loss 0.006 | lr 0.500000

|epoch8| 50/ 152 batches|train_acc0.968 train_loss0.00212

|epoch8| 100/ 152 batches|train_acc0.967 train_loss0.00226

|epoch8| 150/ 152 batches|train_acc0.963 train_loss0.00241

| epoch 8 | time:1.00s | valid_acc 0.891 valid_loss 0.006 | lr 0.500000

|epoch9| 50/ 152 batches|train_acc0.964 train_loss0.00221

|epoch9| 100/ 152 batches|train_acc0.971 train_loss0.00219

|epoch9| 150/ 152 batches|train_acc0.970 train_loss0.00217

| epoch 9 | time:1.18s | valid_acc 0.892 valid_loss 0.006 | lr 0.050000

|epoch10| 50/ 152 batches|train_acc0.967 train_loss0.00224

|epoch10| 100/ 152 batches|train_acc0.971 train_loss0.00214

|epoch10| 150/ 152 batches|train_acc0.969 train_loss0.00216

| epoch 10 | time:1.22s | valid_acc 0.892 valid_loss 0.006 | lr 0.005000

模型准确率为：0.8917

4.3 测试指定数据

代码如下：

python 复制代码

#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 = "还有双鸭山到淮阴的汽车票吗13号的"
model = model.to("cpu")

print("该文本的类别是: %s" % label_name[predict(ex_text_str, text_pipeline)])

打印输出如下：

该文本的类别是: Travel-Query

预测准确

五、优化

尝试了修改初始学习率为3，模型准确率能达到0.9095%

但是由于没有通过随机种子固定模型，每次实验结果存在差异，后续需要增加随机种子函数来保证模型的可重复性进而进行有效的对比分析

总结

在上周的基础上实现了从本地加载数据文件进行分类，对文本分类的步骤更加清晰了