深度学习每周学习总结N3(文本分类实战:基本分类(熟悉流程)、textCNN分类(通用模型)、Bert分类(模型进阶))

0. 总结:

之前有学习过文本预处理的环节,对文本处理的主要方式有以下三种:

1:词袋模型(one-hot编码)

2:TF-IDF

3:Word2Vec(词向量(Word Embedding) 以及Word2vec(Word Embedding 的方法之一))

详细介绍及中英文分词详见pytorch文本分类(一):文本预处理

上期主要介绍Embedding,及EmbeddingBag 使用示例(对词索引向量转化为词嵌入向量)

本期将主要介绍基本分类(熟悉流程)、拓展:textCNN分类(通用模型)、拓展:Bert分类(模型进阶)

1. 前期准备

环境安装

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

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

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

注:相近版本也可,不必完全一致

安装版本参考

PyTorch version torchtext version Supported Python version
nightly build main >=3.8, <=3.11
2.3.0 0.18.0 >=3.8, <=3.11
2.2.0 0.17.0 >=3.8, <=3.11
2.1.0 0.16.0 >=3.8, <=3.11
2.0.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
# 根据上述表格检查自己的python版本及 pytorch版本
import sys
print(sys.version)
3.8.17 | packaged by conda-forge | (default, Jun 16 2023, 07:01:59) [MSC v.1929 64 bit (AMD64)]
import torch
print(torch.__version__)
2.0.0+cpu

综上torchtext应该安装的版本号是 0.15.0

import torchtext
import portalocker

print(torchtext.__version__)
print(portalocker.__version__)
0.15.0
2.10.0

2. 文本分类基本流程

a. 加载数据

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

warnings.filterwarnings("ignore")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
C:\Users\Cheng\.conda\envs\pytorch_env_cuda12_0\lib\site-packages\torchvision\io\image.py:13: UserWarning: Failed to load image Python extension: 'Could not find module 'C:\Users\Cheng\.conda\envs\pytorch_env_cuda12_0\Lib\site-packages\torchvision\image.pyd' (or one of its dependencies). Try using the full path with constructor syntax.'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?
  warn(





device(type='cpu')
from torchtext.datasets import AG_NEWS

train_iter = AG_NEWS('./data/ag_news',split='train') # 加载 AG News 数据集 ,注意最好指定路径,默认路径可能会报错

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


一条新闻文章的文本内容。


新闻文章所属的类别(一个整数,从1到4,分别对应世界、科技、体育和商业)。

b.构建词典

try:
    import portalocker
    print("库已安装")
except ImportError:
    print("库未安装")
库已安装
from torchtext.data.utils import get_tokenizer          # 导入用于获取分词器的get_tokenizer函数
from torchtext.vocab import build_vocab_from_iterator   # 用于从迭代器构建词汇表的build_vocab_from_iterator函数

tokenizer = get_tokenizer('basic_english') # 获取分词器

# 定义生成器函数 yield_tokens
def yield_tokens(data_iter):
    for _,text in data_iter:  # 从数据迭代器 data_iter 中提取文本
        yield tokenizer(text) # 对于每一条数据,tokenizer(text) 会返回一个单词列表,并通过 yield 语句将其生成器输出
        
vocab = build_vocab_from_iterator(yield_tokens(train_iter),specials=["<unk>"]) # 使用 yield_tokens(train_iter) 生成的单词列表构建词汇表
vocab.set_default_index(vocab["<unk>"]) # 设置默认索引,如果找不到单词,则会选择默认索引<unk>

数据处理示例:

(0, "This is a sentence")
(1, "Another sentence")

处理过程如下:

  1. 分词

    • “This is a sentence” -> ['this', 'is', 'a', 'sentence']
    • “Another sentence” -> ['another', 'sentence']
  2. 构建词汇表

    • 词汇表将包含:['this', 'is', 'a', 'sentence', 'another', '<unk>']
  3. 设置默认索引

    • 对于词汇表中不存在的单词,例如 “unknown”,将被映射为 <unk> 的索引。

这样,通过分词和构建词汇表,可以将原始文本数据转换为模型可以处理的数值形式(单词索引),从而进行后续的训练和预测。

  1. 文本数据转换
    • “vocab([‘this’, ‘is’, ‘a’, ‘sentence’, ‘another’, ‘’])” -> [52, 21, 5, 2993, 206, 0]

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

# 自定义函数
text_pipeline = lambda x: vocab(tokenizer(x)) #用于将输入的文本通过分词器分词,然后映射到词汇表的索引序列上
label_pipeline = lambda x: int(x) - 1 # 将标签转换为整数并减去 1。这里假设标签从 1 开始,因此减去 1 以适应从 0 开始的索引。
# 自定义函数使用说明
text_pipeline('here is the an example')
[475, 21, 2, 30, 5297]
# 自定义函数使用说明
label_pipeline('10'),label_pipeline('11') 
(9, 10)
from torch.utils.data import DataLoader

def collate_batch(batch):
    label_list,text_list,offsets = [],[],[0] # 初始化为空列表,其中 offsets 初始化为 [0]。
    
    for (_label,_text) in batch: # 遍历批处理中的每个数据项。_label 是标签,_text 是文本。
        # 标签列表
        label_list.append(label_pipeline(_label)) # 将处理后的标签添加到 label_list。
        # 文本列表
        processed_text = torch.tensor(text_pipeline(_text),dtype=torch.int64) # 将处理后的文本转换为 PyTorch 的 tensor 并指定数据类型为 int64
        text_list.append(processed_text) # 将处理后的文本添加到 text_list
        
        # 偏移量,即语句的总词汇量
        offsets.append(processed_text.size(0)) # 记录每个文本的长度,作为偏移量
        
    label_list = torch.tensor(label_list,dtype = torch.int64) # 将标签列表转换为 PyTorch 的 tensor
    text_list = torch.cat(text_list)                          # 将所有处理后的文本拼接成一个长的 tensor
    offsets = torch.tensor(offsets[:-1]).cumsum(dim = 0)      # 返回维度dim中输入元素的累计和
    
    return label_list.to(device),text_list.to(device),offsets.to(device) # 计算每个文本的偏移量,使用累计和来表示每个文本在拼接后的长 tensor 中的起始位置

# 数据加载器
dataloader = DataLoader(
    train_iter,
    batch_size = 8,
    shuffle = False,
    collate_fn = collate_batch # 指定批处理函数 collate_batch 用于将一批数据合并为一个小批次。
)

疑问解答:解释为什么文本数据需要在处理后立即转换为 tensor,而标签数据则可以延迟到最后统一转换

其实,文本数据处理后立即转换为 tensor 并拼接,与标签数据在最后统一转换是两种不同的数据处理策略,它们各自有其原因和意义。以下是详细的原因和可能的改进方法:

    1. 标签处理:延迟转换
label_list.append(label_pipeline(_label))

标签数据处理非常简单,只是将标签值转换为整数,并不涉及复杂的操作或大规模的数据处理。因此,将所有标签处理完成后再一次性转换为 tensor 是可行且高效的。

    1. 文本处理:立即转换并拼接
processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
text_list.append(processed_text)

立即转换为 tensor 并拼接主要是为了方便后续的拼接操作和偏移量计算。这种方式确保每个文本处理后的格式一致,也避免了额外的遍历和类型转换操作。

  • 统一转换的可行性
    为了统一操作,可以将所有文本处理完后再进行转换和拼接。以下是修改后的代码示例:

  • 修改后的 collate_batch 函数(虽然代码更简洁,但处理大规模数据或比较复杂的预处理时仍然建议不使用这种修改)

def collate_batch(batch):
    label_list, text_list, offsets = [], [], [0]
    
    for (_label, _text) in batch:
        label_list.append(label_pipeline(_label))
        text_list.append(text_pipeline(_text))  # 先将文本处理为索引列表,暂时不转换为 tensor
        offsets.append(len(text_list[-1]))  # 记录每个文本的长度
    
    label_list = torch.tensor(label_list, dtype=torch.int64)  # 统一转换为 tensor
    
    # 统一转换 text_list 并拼接
    text_list = [torch.tensor(text, dtype=torch.int64) for text in text_list]
    text_list = torch.cat(text_list)
    
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)  # 计算偏移量
    
    return label_list.to(device), text_list.to(device), offsets.to(device)

d.定义模型及实例

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

在这里插入图片描述

from torch import nn

class TextClassificationModel(nn.Module):
    def __init__(self,vocab_size,embed_dim,num_class):
        super(TextClassificationModel,self).__init__() # 调用父类 nn.Module 的初始化函数
        # 词嵌入层,它能够对一系列词嵌入的输入进行平均或求和
        self.embedding = nn.EmbeddingBag(
            vocab_size, # 词典大小
            embed_dim,  # 嵌入的维度
            sparse = False
        )
        # 全连接层,它接受嵌入向量的维度 embed_dim 作为输入,并输出 num_class 个类别的得分
        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) # 将嵌入层的权重初始化为均匀分布,范围在 [-0.5, 0.5] 之间
        self.fc.weight.data.uniform_(-initrange,initrange) # 将全连接层的权重初始化为均匀分布,范围在 [-0.5, 0.5] 之间
        self.fc.bias.data.zero_() # 将全连接层的偏置初始化为 0
        
    def forward(self,text,offsets):
        embedded = self.embedding(text,offsets) # 将输入的 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 是一个正数。

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

# 定义实例
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)

e. 定义训练函数

import time

def train(dataloader):
    model.train() # 切换为训练模式
    total_acc,train_loss,total_count = 0,0,0
    log_interval = 500 # 设定日志记录间隔,每 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:
            elapesd = 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()

f.定义评估函数

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

g. 拆分数据集并训练模型

from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset

# 超参数
EPOCH = 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() # 加载数据
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) # 使用前面定义的 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,EPOCH + 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('=' * 61)
    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('=' * 61)
| epoch1 |  500/1782 batches | train_acc 0.904 train_loss 0.00454
| epoch1 | 1000/1782 batches | train_acc 0.903 train_loss 0.00452
| epoch1 | 1500/1782 batches | train_acc 0.909 train_loss 0.00433
=============================================================
| epoch 1 | time:31.01s | valid_acc 0.007 valid_loss 0.005
=============================================================
| epoch2 |  500/1782 batches | train_acc 0.918 train_loss 0.00378
| epoch2 | 1000/1782 batches | train_acc 0.919 train_loss 0.00379
| epoch2 | 1500/1782 batches | train_acc 0.916 train_loss 0.00386
=============================================================
| epoch 2 | time:32.03s | valid_acc 0.007 valid_loss 0.005
=============================================================
| epoch3 |  500/1782 batches | train_acc 0.929 train_loss 0.00328
| epoch3 | 1000/1782 batches | train_acc 0.922 train_loss 0.00356
| epoch3 | 1500/1782 batches | train_acc 0.927 train_loss 0.00340
=============================================================
| epoch 3 | time:32.34s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch4 |  500/1782 batches | train_acc 0.943 train_loss 0.00269
| epoch4 | 1000/1782 batches | train_acc 0.945 train_loss 0.00268
| epoch4 | 1500/1782 batches | train_acc 0.944 train_loss 0.00272
=============================================================
| epoch 4 | time:32.00s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch5 |  500/1782 batches | train_acc 0.946 train_loss 0.00261
| epoch5 | 1000/1782 batches | train_acc 0.947 train_loss 0.00258
| epoch5 | 1500/1782 batches | train_acc 0.946 train_loss 0.00262
=============================================================
| epoch 5 | time:32.56s | valid_acc 0.008 valid_loss 0.004
=============================================================
| epoch6 |  500/1782 batches | train_acc 0.948 train_loss 0.00257
| epoch6 | 1000/1782 batches | train_acc 0.950 train_loss 0.00252
| epoch6 | 1500/1782 batches | train_acc 0.946 train_loss 0.00256
=============================================================
| epoch 6 | time:41.89s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch7 |  500/1782 batches | train_acc 0.948 train_loss 0.00252
| epoch7 | 1000/1782 batches | train_acc 0.950 train_loss 0.00245
| epoch7 | 1500/1782 batches | train_acc 0.949 train_loss 0.00249
=============================================================
| epoch 7 | time:38.78s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch8 |  500/1782 batches | train_acc 0.950 train_loss 0.00249
| epoch8 | 1000/1782 batches | train_acc 0.950 train_loss 0.00245
| epoch8 | 1500/1782 batches | train_acc 0.950 train_loss 0.00244
=============================================================
| epoch 8 | time:37.05s | valid_acc 0.008 valid_loss 0.004
=============================================================
| epoch9 |  500/1782 batches | train_acc 0.951 train_loss 0.00238
| epoch9 | 1000/1782 batches | train_acc 0.949 train_loss 0.00251
| epoch9 | 1500/1782 batches | train_acc 0.950 train_loss 0.00245
=============================================================
| epoch 9 | time:39.89s | valid_acc 0.007 valid_loss 0.004
=============================================================
| epoch10 |  500/1782 batches | train_acc 0.949 train_loss 0.00252
| epoch10 | 1000/1782 batches | train_acc 0.951 train_loss 0.00250
| epoch10 | 1500/1782 batches | train_acc 0.948 train_loss 0.00246
=============================================================
| epoch 10 | time:33.48s | valid_acc 0.007 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 数据集。这样,我们可以通过索引直接访问数据集中的特定样本,从而简化了训练、验证和测试过程中的数据处理。

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

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.006

3. 拓展:textCNN分类(通用模型)


4. 拓展:Bert分类(模型进阶)




最近更新

  1. 在 Ubuntu Server 22.04 上安装 Docker 的详细步骤

    2024-07-09 17:04:08       0 阅读

热门阅读

  1. RabbitMQ实现延迟消息

    2024-07-09 17:04:08       9 阅读
  2. 【数据挖掘】银行信用卡风险大数据分析与挖掘

    2024-07-09 17:04:08       7 阅读
  3. emacs 重新加载磁盘上的文件

    2024-07-09 17:04:08       7 阅读
  4. Linux学习笔记(一)

    2024-07-09 17:04:08       6 阅读
  5. 用WPF实现的窗体是怎么运行的?

    2024-07-09 17:04:08       8 阅读
  6. Mac OS M3 安装 Docker 并解决芯片不支持问题

    2024-07-09 17:04:08       4 阅读
  7. Fedora 41 移除 Python 2支持

    2024-07-09 17:04:08       7 阅读