第N5周：Pytorch文本分类入门

本人往期文章可查阅： 深度学习总结

本周任务：

• 1.了解文本分类的基本流程
• 2.学习常用的数据清洗方法
• 3.学习如何使用jieba实现英文分词
• 4.学习如何构建文本向量

🏡 我的环境：

• 语言环境：Python3.11

• 编译器：PyCharm

• 深度学习环境：Pytorch

• • torch==2.0.0+cu118

• • torchvision==0.18.1+cu118
• 显卡：NVIDIA GeForce GTX 1660

一、前期准备

1. 环境安装

这是一个使用pytorch实现的简单文本分类实战案例。在这个例子中，我们将使用AG News数据集进行文本分类。

AG News（AG's News Topic Classification Dataset）是一个广泛用于文本分类任务的数据集，尤其是在新闻领域。该数据集是有AG's Corpus of News Articles 收集整理而来，包含了四个主要的类别：世界、体育、商业和科技。

首先，确保已经安装了 torchtext 与 portalocker 库

我的版本号是：

• torchtext==0.15.1
• portalocker==2.7.0

注：相近版本也可，不必完全一致

其中，torchtext 安装版本参考：

|-----------------|------------------|--------------------------|
| PyTorch version | tochtext version | Supported Python version |
| nightly build | main | >=3.8, <=3.11 |
| 1.14.0 | 0.15.0 | >=3.8, <=3.11 |
| 1.13.0 | 0.14.0 | >=3.7, <=3.10 |
| 1.12.0 | 0.13.0 | >=3.7, <=3.10 |
| 1.11.0 | 0.12.0 | >=3.6, <=3.9 |
| 1.10.0 | 0.11.0 | >=3.6, <=3.9 |
| 1.9.1 | 0.10.1 | >=3.6, <=3.9 |
| 1.9 | 0.10 | >=3.6, <=3.9 |
| 1.8.1 | 0.9.1 | >=3.6, <=3.9 |
| 1.8 | 0.9 | >=3.6, <=3.9 |
| 1.7.1 | 0.8.1 | >=3.6, <=3.9 |
| 1.7 | 0.8 | >=3.6, <=3.8 |
| 1.6 | 0.7 | >=3.6, <=3.8 |
| 1.5 | 0.6 | >=3.5, <=3.8 |
| 1.4 | 0.5 | 2.7, >=3.5, <=3.8 |
| 0.4 and below | 0.2.3 | 2.7, >=3.5, <=3.8 |

2. 加载数据

import torch
import torch.nn as nn
import torchvision
from torchvision import transforms,datasets
import os,PIL,pathlib,warnings

warnings.filterwarnings("ignore")  # 忽略警告信息

# win10系统，调用GPU运行
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

# 苹果系统，调用M2芯片
# device=torch.device("mps")
# device

运行结果：

device(type='cuda')

---

torchtext.datasets.AG_NEWS() 是一个用于加载 AG News 数据集的 TorchText 数据集类。AG News 数据集是一个用于文本分类任务的常见数据集，其中包含四个类别的新闻文章：世界、科技、体育和商业。 torchtext.datasets.AG_NEWS() 类加载的数据集是一个列表，其中每个条目都是一个元组，包含以下两个元素：

• 一条新闻文章的文本内容
• 新闻文章所属的类别（一个整数，从1到4，分别对应世界、科技、体育和商业）

torchtext.datasets.AG_NEWS() 类构造函数的参数如下：

• root ：数据集的根目录。默认值是" .data "
• split ：数据集的拆分 train、test
• **kwargs ：可选的关键字参数，可传递给 torchtext.datasets.TextClassificationDataset 类的构造函数

注：常见的加载 AG News数据的命令如下：

import torchtext.datasets as datasets

# 加载 AG News数据集
train_dataset,test_dataset=datasets.AG_NEWS(root=".data",split=("train","test"))

但由于本人网速问题，一直显示连接超时，无法下载。故我先创建设定的文件夹，将数据集单独下载之后，放入该文件夹内 ，然后再进行加载。实际操作中可以根据个人需求进行操作。

from torchtext.datasets import AG_NEWS

# 创建数据存储目录
os.makedirs(r'E:\DATABASE\N-series\N5',exist_ok=True)

# 加载 AG News 数据集
train_iter,test_iter=AG_NEWS(root=r'E:\DATABASE\N-series\N5',split=('train','test')) 

3. 构建词典

from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator

# 返回分词器函数
tokenizer=get_tokenizer('basic_english')

# 定义生成 tokens 的函数
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>"])

torchtext.data.utils.get_tokenizer() 是一个用于将文本数据分词的函数。作用是根据指定的分词器名称或自定义函数，生成一个分词器对象（tokenizer），可以将一个字符串转换成一个单词的列表。这个函数可以接受两个参数：tokenizer 和 language，tokenizer 参数指定要使用的分词器的名称。 它支持多种预定义的分词器，也可以使用自定义的分词函数。

示例：

from torchtext.data.utils import get_tokenizer

# 获取基本英文分词器
tokenizer = get_tokenizer("basic_english")

# 示例文本
text = "This is a sample sentence for tokenization."

# 分词
tokens = tokenizer(text)
print("Original text:", text)
print("Tokenized text:", tokens)

输出：

Original text: This is a sample sentence for tokenization.
Tokenized text: ['this', 'is', 'a', 'sample', 'sentence', 'for', 'tokenization', '.']

get_tokenizer() 支持以下分词器：

• "basic_english": 简单的英文分词器，将文本转换为小写并按空格分割。

• "spacy" : 使用 spacy 库的分词器。

• "moses" : 使用 sacremoses 库的分词器。

• "toktok" : 使用 nltk 库的分词器。

• "revtok" : 使用 revtok 库的分词器。

• "subword" : 使用 subword 库的分词器。

---

torchtext.vocab.build_vocab_from_iterator(
    iterator,
    specials=None,
    min_freq=1,
    max_size=None,
    vectors=None,
    vectors_cache=None,
    unk_init=None,
    special_first=True
)

build_vocab_from_iterator 的参数如下：

• iterator: 一个生成器或迭代器，逐个返回分词后的文本（通常是标记列表）。

• specials : 一个列表，包含特殊标记（如 <unk>、<pad> 等）。这些标记会被添加到词汇表中，并分配固定的索引。

• min_freq: 最小频率，默认为 1。只有出现次数大于或等于该值的单词才会被加入词汇表。

• max_size: 词汇表的最大大小。如果指定，词汇表的大小不会超过该值。

• vectors: 可选参数，用于加载预训练的词嵌入向量。

• vectors_cache: 预训练向量的缓存路径。

• unk_init: 未知单词的初始化方法，默认为随机初始化。

---

---

原函数中：

• yield_tokens(train_iter): 这是一个生成器，逐个返回分词后的文本。

• specials=["<unk>"] : 指定特殊标记，<unk> 通常用于表示未知单词。

• vocab: 构建的词汇表对象，可以将单词映射到索引。

假设数据集：

train_iter = [
    (0, "This is a sample sentence."),
    (1, "Another example text."),
    (0, "Text classification is fun!")
]

使用生成器构建词汇表并设置默认索引后，打印词汇表：

print("Vocabulary:", vocab)
print("Token to Index:", vocab["sample"])
print("Unknown Token Index:", vocab["unknown_token"])

输出：

Vocabulary: <torchtext.vocab.Vocab object at 0x...>
Token to Index: 4
Unknown Token Index: 0

---

print(vocab(['here','is','an','example']))

运行结果：

[475, 21, 30, 5297]

text_pipeline=lambda x:vocab(tokenizer(x))
label_pipeline=lambda x:int(x)-1

text_pipeline('here is the an example')

运行结果：

[475, 21, 2, 30, 5297]

---

label_pipeline('10')

运行结果：

9

4. 生成数据批次和迭代器

from torch.utils.data import DataLoader

def collate_batch(batch):
    label_list,text_list,offsets=[],[],[0]
    
    for (_label,_text) 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 label_list.to(device),text_list.to(device),offsets.to(device)

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

collate_batch 函数定义了一个自定义的批处理函数，用于处理文本数据和标签，并将其转换为适合模型输入的格式。这个函数特别适用于处理文本分类任务中的批次数据。

1.4.1 输入

collate_batch 的输入是一个批次数据 batch，其中每个元素是一个元组 (_label, _text)，表示一个样本的标签和文本内容。

1.4.2 变量初始化

label_list, text_list, offsets = [], [], [0]

• label_list: 用于存储处理后的标签。

• text_list: 用于存储处理后的文本数据（索引列表）。

• offsets: 用于存储每个样本的文本长度的累积和，用于后续的嵌入操作。

1.4.3 处理每个样本

for (_label, _text) 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))  # 记录每个样本的文本长度

1.4.4 转换为张量

label_list = torch.tensor(label_list, dtype=torch.int64)  # 转换标签列表为张量
text_list = torch.cat(text_list)  # 将文本列表拼接成一个张量
offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)  # 计算偏移量的累积和

• offsets 是一个列表，记录了每个样本的文本长度。

• offsets[:-1] 表示取 offsets 列表的所有元素，除了最后一个元素。

• 原因是最后一个元素是所有样本的总长度，而我们只需要每个样本的累积长度。

• torch.tensor(offsets[:-1])： 将 offsets[:-1] 转换为一个 PyTorch 张量。

• .cumsum(dim=0)： 计算张量的累积和（cumulative sum）。dim=0 表示沿着第 0 维度（即列表的主维度）进行累积和计算。

示例：

假设我们有以下文本数据：

texts = ["This is a sample text.", "Another example text."]

分词后的结果如下：

text_pipeline("This is a sample text.") -> [1, 2, 3, 4, 5]
text_pipeline("Another example text.") -> [6, 7, 8]

计算 offsets：

offsets = [0, 5, 8]  # 每个样本的文本长度

处理 offsets ：

offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)

输出：

print(offsets)

结果：

tensor([0, 5])

解释

• **offsets**的含义：

  • 0: 第一个样本的起始位置。

  • 5: 第二个样本的起始位置（第一个样本的长度为 5）。

• 累积和：

  • cumsum 的作用是将每个元素替换为从列表开头到该元素的累积和。

  • 例如，[0, 5, 8] 的累积和为 [0, 5]（最后一个元素被丢弃）。

二、准备模型

1. 定义模型

这里我们定义TextClassificationModel 模型，首先对文本进行嵌入，然后对句子嵌入之后的结果进行均值聚合。

from torch import nn

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  # 是否使用稀疏梯度（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）权重的一种方法。这里使用了均匀分布的随机值来初始化权重，具体来说，其作用如下：

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

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

---

def forward(self,text,offsets):
        embedded=self.embedding(text,offsets)
        return self.fc(embedded)

（1）参数

• text: 一个一维张量，包含所有样本的单词索引。

• offsets: 一个一维张量，包含每个样本的起始索引位置。

（2）self.embedding

• self.embedding 是一个 torch.nn.EmbeddingBag 层。

• 它接受两个参数：

  • text: 包含所有单词索引的张量。

  • offsets: 每个样本的起始索引位置。

• EmbeddingBag 会根据 offsets 将 text 分割成多个"袋"（即样本），并对每个"袋"中的嵌入向量进行聚合（如求和或平均）。

（3） self.fc

• self.fc 是一个全连接层，用于将嵌入向量映射到输出维度。

• 它接受 EmbeddingBag 的输出，并返回最终的预测结果。

2. 定义实例

num_class=len(set([label for (label,text) in train_iter]))
vocab_size=len(vocab)
em_size=64
model=TextClassificationModel(vocab_size,em_size,num_class).to(device)

3. 定义训练函数与评估函数

import time

criterion = nn.CrossEntropyLoss()

def train(dataloader):
    model.train() # 切换为训练模式
    # 初始化变量，分别用于累计训练过程中的准确率、损失和样本数量
    total_acc,train_loss,total_count=0,0,0
    # 每隔 log_interval 步记录一次训练进度，方便监控训练过程
    log_interval=500
    # 用于计算训练过程中的耗时
    start_time=time.time()
    
    for idx,(label,text,offsets) in enumerate(dataloader):
        
        predicted_label=model(text,offsets)
        
        optimizer.zero_grad() # grad属性归零
        loss=criterion(predicted_label,label) # 计算网络输出和真实值之间的差距，label为真实值
        loss.backward() # 反向传播
        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{:1d} | {: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,(label,text,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

三、训练模型

1. 拆分数据集并运行模型

from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset
# 超参数
EPOCHS=10 # epoch
LR=5 # 学习率
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,test_iter=AG_NEWS(root=r'E:\DATABASE\N-series\N5',split=('train','test')) # 加载数据
train_dataset=to_map_style_dataset(train_iter)
test_dataset=to_map_style_dataset(test_iter)
num_train=int(len(train_dataset)*0.95)

split_train_,split_valid_=random_split(
    train_dataset,
    [num_train,len(train_dataset)-num_train]
)
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
)
test_dataloader=DataLoader(
    test_dataset,batch_size=BATCH_SIZE,
    shuffle=True,collate_fn=collate_batch
)

for epoch in range(1,EPOCHS+1):
    epoch_start_time=time.time()
    train(train_dataloader)
    val_acc,val_loss=evaluate(valid_dataloader)
    
    if total_accu is not None and total_accu>val_acc:
        scheduler.step()
    else:
        total_accu=val_acc
    print('-'*69)
    print('| epoch{:1d} | time:{:4.2f}s |'
          'valid_acc {:4.3f} valid_loss {:4.3f}'.format(epoch,
                                                        time.time()-epoch_start_time,
                                                        val_acc,val_loss))
    print('-'*69)

运行结果：

| epoch1 |  500/1782 batches | train_acc 0.711 | train_loss 0.01143
| epoch1 | 1000/1782 batches | train_acc 0.867 | train_loss 0.00615
| epoch1 | 1500/1782 batches | train_acc 0.886 | train_loss 0.00532
---------------------------------------------------------------------
| epoch1 | time:10.26s |valid_acc 0.857 valid_loss 0.006
---------------------------------------------------------------------
| epoch2 |  500/1782 batches | train_acc 0.905 | train_loss 0.00447
| epoch2 | 1000/1782 batches | train_acc 0.905 | train_loss 0.00438
| epoch2 | 1500/1782 batches | train_acc 0.901 | train_loss 0.00462
---------------------------------------------------------------------
| epoch2 | time:10.28s |valid_acc 0.896 valid_loss 0.005
---------------------------------------------------------------------
| epoch3 |  500/1782 batches | train_acc 0.919 | train_loss 0.00374
| epoch3 | 1000/1782 batches | train_acc 0.916 | train_loss 0.00388
| epoch3 | 1500/1782 batches | train_acc 0.914 | train_loss 0.00391
---------------------------------------------------------------------
| epoch3 | time:10.65s |valid_acc 0.896 valid_loss 0.005
---------------------------------------------------------------------
| epoch4 |  500/1782 batches | train_acc 0.929 | train_loss 0.00330
| epoch4 | 1000/1782 batches | train_acc 0.925 | train_loss 0.00341
| epoch4 | 1500/1782 batches | train_acc 0.921 | train_loss 0.00360
---------------------------------------------------------------------
| epoch4 | time:11.16s |valid_acc 0.883 valid_loss 0.005
---------------------------------------------------------------------
| epoch5 |  500/1782 batches | train_acc 0.943 | train_loss 0.00272
| epoch5 | 1000/1782 batches | train_acc 0.942 | train_loss 0.00278
| epoch5 | 1500/1782 batches | train_acc 0.943 | train_loss 0.00271
---------------------------------------------------------------------
| epoch5 | time:11.58s |valid_acc 0.918 valid_loss 0.004
---------------------------------------------------------------------
| epoch6 |  500/1782 batches | train_acc 0.948 | train_loss 0.00260
| epoch6 | 1000/1782 batches | train_acc 0.945 | train_loss 0.00263
| epoch6 | 1500/1782 batches | train_acc 0.944 | train_loss 0.00267
---------------------------------------------------------------------
| epoch6 | time:12.00s |valid_acc 0.919 valid_loss 0.004
---------------------------------------------------------------------
| epoch7 |  500/1782 batches | train_acc 0.946 | train_loss 0.00264
| epoch7 | 1000/1782 batches | train_acc 0.948 | train_loss 0.00248
| epoch7 | 1500/1782 batches | train_acc 0.946 | train_loss 0.00260
---------------------------------------------------------------------
| epoch7 | time:10.66s |valid_acc 0.918 valid_loss 0.004
---------------------------------------------------------------------
| epoch8 |  500/1782 batches | train_acc 0.952 | train_loss 0.00239
| epoch8 | 1000/1782 batches | train_acc 0.949 | train_loss 0.00253
| epoch8 | 1500/1782 batches | train_acc 0.947 | train_loss 0.00252
---------------------------------------------------------------------
| epoch8 | time:11.81s |valid_acc 0.919 valid_loss 0.004
---------------------------------------------------------------------
| epoch9 |  500/1782 batches | train_acc 0.947 | train_loss 0.00253
| epoch9 | 1000/1782 batches | train_acc 0.948 | train_loss 0.00250
| epoch9 | 1500/1782 batches | train_acc 0.951 | train_loss 0.00244
---------------------------------------------------------------------
| epoch9 | time:11.17s |valid_acc 0.919 valid_loss 0.004
---------------------------------------------------------------------
| epoch10 |  500/1782 batches | train_acc 0.948 | train_loss 0.00254
| epoch10 | 1000/1782 batches | train_acc 0.950 | train_loss 0.00244
| epoch10 | 1500/1782 batches | train_acc 0.949 | train_loss 0.00247
---------------------------------------------------------------------
| epoch10 | time:12.12s |valid_acc 0.920 valid_loss 0.004
---------------------------------------------------------------------

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 数据集。这样，我们可以通过索引直接访问数据集中的特定样本，从而简化了训练、验证和测试过程中的数据处理。

2. 使用测试数据集评估模型

print('Checking the results of test dataset.')
test_acc,test_loss=evaluate(test_dataloader)
print('test accuracy {:8.3f}'.format(test_acc))

运行结果：

Checking the results of test dataset.
test accuracy    0.910

四、心得体会

通过上述学习，了解了文本分类的基本流程，对其中建模过程有了更加深刻的认识。