- 🍨 本文为🔗365天深度学习训练营中的学习记录博客
- 🍖 原作者：K同学啊
本周任务：
1.了解文本分类的基本流程
2.学习常用数据清洗方法
3.学习如何使用jieba实现英文分词
4.学习如何构建文本向量
一、前期准备
1.环境安装
使用的是pytorch实现简单文本分类，将使用AGNews数据集进行文本分类。
AGNews（AG's News Topic Classification Dataset）是一个广泛用于文本分类任务的数据集，尤其在新闻领域。该数据集由AG's Corpus of News Articles收集整理而来，包含四个主要类别：世界、体育、商业和科技。
确保已经安装了torchtext和portalocker库
2.加载数据
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")
print(device)
输出：
from torchtext.datasets import AG_NEWS
# 加载 AG News数据集
train_iter = AG_NEWS(split='train')
torchtext.datasets.AG_NEWS() ：用于加载 AG News 数据集的 TorchText 数据集类。AG News 数据集是一个用于文本分类任务的常见数据集，其中包含四个类别的新闻文章：世界、科技、体育和商业。 torchtext.datasets.AG_NEWS() 类加载的数据集是一个列表，其中每个条目都是一个元组，包含以下两个元素：
- 一条新闻文章的文本内容
- 新闻文章所属的类别（一个整数，从1到4，分别对应世界、科技、体育和商业）
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>"])输出：
vocab（['here', 'is' , 'an' , 'example']）
[475,21,30,5297]
torchtext.data.utils.get_tokenizer() 是一个用于将文本数据分词的函数。它返回一个分词器（tokebnizer）函数，可以将一个字符串转换成一个单词的列表。这个函数可以接受两个参数：tokenizer 和 language，tokenizer 参数指定要使用的分词器的名称。
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)二、准备模型
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是一个正数。
通过这种方式初始化词嵌入层的权重，可以使得模型在训练时具有一定的随机性，有助于避免梯度小时或梯度爆炸等问题。在训练过程中，这些权重将通过优化算法不断更新，以捕捉更好的单词表示。
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)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
四、总结
每周对代码的学习不多，导致很多东西都是短暂记忆，经常忘记很久之前的，需要时刻复习之前学习过的内容，避免出问题，影响后续专题的学习。
这个耽误了自己好久，无语！！！