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

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊 | 接辅导、项目定制

- 0. 总结：
- 1. 前期准备
- - 环境安装
- 2. 文本分类基本流程
- - a. 加载数据
  - b.构建词典
  - c.生成数据批次和迭代器
  - d.定义模型及实例
  - e. 定义训练函数
  - f.定义评估函数
  - g. 拆分数据集并训练模型
  - h. 使用测试集数据评估模型
- 3. 拓展：textCNN分类（通用模型）
- 4. 拓展：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")

处理过程如下：

分词：
- “This is a sentence” -> ['this', 'is', 'a', 'sentence']
- “Another sentence” -> ['another', 'sentence']
构建词汇表：
- 词汇表将包含：['this', 'is', 'a', 'sentence', 'another', '<unk>']
设置默认索引：
- 对于词汇表中不存在的单词，例如 “unknown”，将被映射为 <unk> 的索引。

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

文本数据转换：
- “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