- 🍨 本文为🔗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 portalockerprint(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,warningswarnings.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_NEWStrain_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 portalockerprint("库已安装")
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” ->
-
构建词汇表：
- 词汇表将包含：
['this', 'is', 'a', 'sentence', 'another', '<unk>']
- 词汇表将包含：
-
设置默认索引：
- 对于词汇表中不存在的单词，例如 “unknown”，将被映射为
<unk>的索引。
- 对于词汇表中不存在的单词，例如 “unknown”，将被映射为
这样，通过分词和构建词汇表，可以将原始文本数据转换为模型可以处理的数值形式（单词索引），从而进行后续的训练和预测。
- 文本数据转换：
- “vocab([‘this’, ‘is’, ‘a’, ‘sentence’, ‘another’, ‘’])” ->
[52, 21, 5, 2993, 206, 0]
- “vocab([‘this’, ‘is’, ‘a’, ‘sentence’, ‘another’, ‘’])” ->
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 DataLoaderdef 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 并指定数据类型为 int64text_list.append(processed_text) # 将处理后的文本添加到 text_list# 偏移量，即语句的总词汇量offsets.append(processed_text.size(0)) # 记录每个文本的长度，作为偏移量label_list = torch.tensor(label_list,dtype = torch.int64) # 将标签列表转换为 PyTorch 的 tensortext_list = torch.cat(text_list) # 将所有处理后的文本拼接成一个长的 tensoroffsets = 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 并拼接，与标签数据在最后统一转换是两种不同的数据处理策略，它们各自有其原因和意义。以下是详细的原因和可能的改进方法：
-
- 标签处理：延迟转换
label_list.append(label_pipeline(_label))
标签数据处理非常简单，只是将标签值转换为整数，并不涉及复杂的操作或大规模的数据处理。因此，将所有标签处理完成后再一次性转换为 tensor 是可行且高效的。
-
- 文本处理：立即转换并拼接
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)) # 先将文本处理为索引列表，暂时不转换为 tensoroffsets.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 nnclass 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_() # 将全连接层的偏置初始化为 0def 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 timedef train(dataloader):model.train() # 切换为训练模式total_acc,train_loss,total_count = 0,0,0log_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 与losstotal_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_timeprint('| 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,0start_time = time.time()
f.定义评估函数
def evaluate(dataloader):model.eval() # 切换为测试模式total_acc,train_loss,total_count = 0,0,0with 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 trainingcriterion = 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 = Nonetrain_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_accprint('=' * 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分类（模型进阶）
