- 本文为365天深度学习训练营 中的学习记录博客
- 原作者：K同学啊
一、数据预处理
任务说明:
本次将加入Word2vec使用PyTorch实现中文文本分类，Word2Vec 则是其中的一种词嵌入方法，是一种用于生成词向量的浅层神经网络模型，由Tomas Mikolov及其团队于2013年提出。Word2Vec通过学习大量文本数据，将每个单词表示为一个连续的向量，这些向量可以捕捉单词之间的语义和句法关系。更详细的内容可见训练营内的NLP基础知识，数据示例如下：
基础任务：
●1. 结合Word2Vec文本内容（第1列）预测文本标签（第2列）
●2. 优化本文网络结构，将准确率提升至89%
●3. 绘制出验证集的ACC与Loss图
进阶任务：
●1. 尝试根据第2周的内容独立实现，尽可能的不看本文的代码
- 加载数据
import torch
import torch.nn as nn
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
warnings.filterwarnings("ignore") #忽略警告信息
# win10系统
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
代码输出
device(type='cpu')
import pandas as pd
# 加载自定义中文数据
train_data = pd.read_csv('./N8/train.csv', sep='\t', header=None)
train_data.head()
代码输出
| 0 | 1 | |
|---|---|---|
| 0 | 还有双鸭山到淮阴的汽车票吗13号的 | Travel-Query |
| 1 | 从这里怎么回家 | Travel-Query |
| 2 | 随便播放一首专辑阁楼里的佛里的歌 | Music-Play |
| 3 | 给看一下墓王之王嘛 | FilmTele-Play |
| 4 | 我想看挑战两把s686打突变团竞的游戏视频 | Video-Play |
# 构造数据集迭代器
def coustom_data_iter(texts, labels):
for x, y in zip(texts, labels):
yield x, y
x = train_data[0].values[:]
#多类标签的one-hot展开
y = train_data[1].values[:]
x,y
代码输出
(array(['还有双鸭山到淮阴的汽车票吗13号的', '从这里怎么回家', '随便播放一首专辑阁楼里的佛里的歌', ...,
'黎耀祥陈豪邓萃雯畲诗曼陈法拉敖嘉年杨怡马浚伟等到场出席', '百事盖世群星星光演唱会有谁', '下周一视频会议的闹钟帮我开开'],
dtype=object),
array(['Travel-Query', 'Travel-Query', 'Music-Play', ..., 'Radio-Listen',
'Video-Play', 'Alarm-Update'], dtype=object))
zip 是 Python 中的一个内置函数，它可以将多个序列（列表、元组等）中对应的元素打包成一个个元组，然后返回这些元组组成的一个迭代器。例如，在代码中 zip(texts, labels) 就是将 texts 和 labels 两个列表中对应位置的元素一一打包成元组，返回一个迭代器，每次迭代返回一个元组 (x, y)，其中 x 是 texts 中的一个元素，y 是 labels 中对应的一个元素。这样，每次从迭代器中获取一个元素，就相当于从 texts 和 labels 中获取了一组对应的数据。在这里，zip 函数主要用于将输入的 texts 和 labels 打包成一个可迭代的数据集，然后传给后续的模型训练过程使用。
- 构建词典
需要另外安装gensim，安装语句pip install gensim，可使用下面博客上提供的镜像进行加速：
常用 镜像_镜像 simple-CSDN博客
from gensim.models.word2vec import Word2Vec
import numpy as np
# 训练 Word2Vec 浅层神经网络模型
w2v = Word2Vec(vector_size=100, #是指特征向量的维度，默认为100。
min_count=3) #可以对字典做截断. 词频少于min_count次数的单词会被丢弃掉, 默认值为5。
w2v.build_vocab(x)
w2v.train(x,
total_examples=w2v.corpus_count,
epochs=20)
代码输出
(2733274, 3663560)
Word2Vec可以直接训练模型，一步到位。这里分了三步：
●第一步构建一个空模型。
●第二步使用 build_vocab 方法根据输入的文本数据 x 构建词典。build_vocab 方法会统计输入文本中每个词汇出现的次数，并按照词频从高到低的顺序将词汇加入词典中。
●第三步使用 train 方法对模型进行训练，total_examples 参数指定了训练时使用的文本数量，这里使用的是 w2v.corpus_count 属性，表示输入文本的数量。
如果一步到位的话代码为：
w2v = Word2Vec(x, vector_size=100, min_count=3, epochs=20)
w2v
代码输出
<gensim.models.word2vec.Word2Vec at 0x1ccd73d8130>
# 将文本转化为向量
def average_vec(text):
vec = np.zeros(100).reshape((1, 100))
for word in text:
try:
vec += w2v.wv[word].reshape((1, 100))
except KeyError:
continue
return vec
# 将词向量保存为 Ndarray
x_vec = np.concatenate([average_vec(z) for z in x])
# 保存 Word2Vec 模型及词向量
w2v.save('./N8/data/w2v_model.pkl')
这段代码定义了一个函数 average_vec(text)，它接受一个包含多个词的列表 text 作为输入，并返回这些词对应词向量的平均值。该函数
● 首先初始化一个形状为 (1, 100) 的全零 numpy 数组来表示平均向量。
● 然后遍历 text 中的每个词，并尝试从 Word2Vec 模型 w2v 中使用 wv 属性获取其对应的词向量。如果在模型中找到了该词，函数将其向量加到 vec中。如果未找到该词，函数会继续迭代下一个词。
● 最后，函数返回平均向量 vec。
然后使用列表推导式将 average_vec() 函数应用于列表 x 中的每个元素。得到的平均向量列表使用 np.concatenate() 连接成一个 numpy 数组 x_vec，该数组表示 x 中所有元素的平均向量。x_vec 的形状为 (n, 100)，其中 n 是 x 中元素的数量。
train_iter = coustom_data_iter(x_vec, y)
len(x),len(x_vec)
代码输出
(12100, 12100)
label_name = list(set(train_data[1].values[:]))
print(label_name)
代码输出
['Alarm-Update', 'Other', 'Radio-Listen', 'Music-Play', 'TVProgram-Play', 'Video-Play', 'HomeAppliance-Control', 'Weather-Query', 'FilmTele-Play', 'Audio-Play', 'Travel-Query', 'Calendar-Query']
- 生成数据批次和迭代器
text_pipeline = lambda x: average_vec(x)
label_pipeline = lambda x: label_name.index(x)
lambda 表达式的语法为：lambda arguments: expression
其中 arguments 是函数的参数，可以有多个参数，用逗号分隔。expression 是一个表达式，它定义了函数的返回值。
●text_pipeline 函数：接受一个包含多个词的列表 x 作为输入，并返回这些词对应词向量的平均值，即调用了之前定义的 average_vec 函数。这个函数用于将原始文本数据转换为词向量平均值表示的形式。
●label_pipeline 函数：接受一个标签名 x 作为输入，并返回该标签名label_name 列表中的索引。这个函数可以用于将原始标签数据转换为数字索引表示的形式。
text_pipeline("你在干嘛")
array([[-0.04543949, 2.20234346, 1.05058477, 1.08593849, -1.28897751,
0.74803635, -0.06330371, 1.58700518, 0.24575421, -1.32403693,
-1.1138861 , -3.79198921, 1.51698652, -0.46545837, 0.49368126,
0.41732261, 2.8207842 , -1.87699896, 3.80442886, -0.76470409,
2.51992944, -0.59959719, -0.39377743, -0.4155187 , -0.80207745,
-1.94636255, -1.71751137, -1.15157906, 2.34745611, -0.88811359,
1.90659964, 1.23957148, -0.92163226, -0.17471965, -0.04162584,
-0.16202128, -0.27601156, 3.61828503, -0.89918844, 0.91991885,
0.50985746, 0.35574163, -0.22598114, 1.5940434 , 0.14057513,
0.83770178, 0.99681325, -0.85999402, -2.56938645, 2.08327347,
-0.25531955, -1.79517481, -0.71188387, 0.58219229, -0.76276238,
-0.64469636, 0.96793754, -0.61803127, 0.26209 , 1.14042565,
1.45644176, -0.8290033 , 2.47536681, -0.66615486, -0.68457059,
0.43816039, -1.67795628, 1.18700068, 1.65407032, -0.07257137,
-0.66152814, 0.9839602 , 1.14941148, -0.30556869, -0.15649345,
0.0537428 , -3.64270853, 0.5475641 , 1.28786314, -0.84606099,
-2.1545399 , 0.01224559, -2.88506868, 2.93610218, -1.7637587 ,
-0.78272004, 1.7797319 , -2.45746924, -0.6527113 , -0.3492835 ,
0.36112074, -1.80893275, 0.37037453, 1.57843871, 1.93336754,
-1.81102024, 0.40875378, 0.9862798 , -2.10714753, 0.37939982]])
label_pipeline("Travel-Query")
代码输出
10
from torch.utils.data import DataLoader
def collate_batch(batch):
label_list, text_list= [], []
for (_text, _label) in batch:
# 标签列表
label_list.append(label_pipeline(_label))
# 文本列表
processed_text = torch.tensor(text_pipeline(_text), dtype=torch.float32)
text_list.append(processed_text)
label_list = torch.tensor(label_list, dtype=torch.int64)
text_list = torch.cat(text_list)
return text_list.to(device),label_list.to(device)
# 数据加载器，调用示例
dataloader = DataLoader(train_iter,
batch_size=8,
shuffle =False,
collate_fn=collate_batch)
二、模型构建
- 搭建模型
注意，这里使用的是最简单的网络，你可以根据自己的基础替换成其他网络，这里就不需要嵌入层了。
from torch import nn
class TextClassificationModel(nn.Module):
def __init__(self, num_class):
super(TextClassificationModel, self).__init__()
self.fc = nn.Linear(100, num_class)
def forward(self, text):
return self.fc(text)
- 初始化模型
num_class = len(label_name)
vocab_size = 100000
em_size = 12
model = TextClassificationModel(num_class).to(device)
- 定义训练与评估函数
import time
def train(dataloader):
model.train() # 切换为训练模式
total_acc, train_loss, total_count = 0, 0, 0
log_interval = 50
start_time = time.time()
for idx, (text,label) in enumerate(dataloader):
predicted_label = model(text)
optimizer.zero_grad() # grad属性归零
loss = criterion(predicted_label, label) # 计算网络输出和真实值之间的差距，label为真实值
loss.backward() # 反向传播
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1) # 梯度裁剪
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, (text,label) in enumerate(dataloader):
predicted_label = model(text)
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
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)是一个PyTorch函数，用于在训练神经网络时限制梯度的大小。这种操作被称为梯度裁剪（gradient clipping），可以防止梯度爆炸问题，从而提高神经网络的稳定性和性能。
在这个函数中：
●model.parameters()表示模型的所有参数。对于一个神经网络，参数通常包括权重和偏置项。
●0.1是一个指定的阈值，表示梯度的最大范数（L2范数）。如果计算出的梯度范数超过这个阈值，梯度会被缩放，使其范数等于阈值。
梯度裁剪的主要目的是防止梯度爆炸。梯度爆炸通常发生在训练深度神经网络时，尤其是在处理长序列数据的循环神经网络（RNN）中。当梯度爆炸时，参数更新可能会变得非常大，导致模型无法收敛或出现数值不稳定。通过限制梯度的大小，梯度裁剪有助于解决这些问题，使模型训练变得更加稳定。
三、训练模型
- 拆分数据集并运行模型
from torch.utils.data.dataset import random_split
from torchtext.data.functional import to_map_style_dataset
import copy
# 超参数
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 = coustom_data_iter(train_data[0].values[:], train_data[1].values[:])
train_dataset = to_map_style_dataset(train_iter)
split_train_, split_valid_ = random_split(train_dataset,
[int(len(train_dataset)*0.8),int(len(train_dataset)*0.2)])
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)
total_val_acc=[]
total_val_loss=[]
# best_val_acc = 0 # 设置一个最佳准确率，作为最佳模型的判别指标
for epoch in range(1, EPOCHS + 1):
epoch_start_time = time.time()
train(train_dataloader)
val_acc, val_loss = evaluate(valid_dataloader)
# 保存最佳模型到 best_model
# if val_acc > best_val_acc:
# best_val_acc = val_acc
# best_model = copy.deepcopy(model)
total_val_acc.append(val_acc)
total_val_loss.append(val_loss)
# 获取当前的学习率
lr = optimizer.state_dict()['param_groups'][0]['lr']
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} | lr {:4.6f}'.format(epoch,
time.time() - epoch_start_time,
val_acc,val_loss,lr))
print('-' * 69)
代码运行结果输出
| epoch 1 | 50/ 152 batches | train_acc 0.748 train_loss 0.02485
| epoch 1 | 100/ 152 batches | train_acc 0.831 train_loss 0.01819
| epoch 1 | 150/ 152 batches | train_acc 0.829 train_loss 0.01851
---------------------------------------------------------------------
| epoch 1 | time: 1.50s | valid_acc 0.811 valid_loss 0.021 | lr 5.000000
---------------------------------------------------------------------
| epoch 2 | 50/ 152 batches | train_acc 0.846 train_loss 0.01745
| epoch 2 | 100/ 152 batches | train_acc 0.844 train_loss 0.01793
| epoch 2 | 150/ 152 batches | train_acc 0.834 train_loss 0.01816
---------------------------------------------------------------------
| epoch 2 | time: 1.48s | valid_acc 0.813 valid_loss 0.024 | lr 5.000000
---------------------------------------------------------------------
| epoch 3 | 50/ 152 batches | train_acc 0.849 train_loss 0.01589
| epoch 3 | 100/ 152 batches | train_acc 0.843 train_loss 0.01812
| epoch 3 | 150/ 152 batches | train_acc 0.852 train_loss 0.01802
---------------------------------------------------------------------
| epoch 3 | time: 1.52s | valid_acc 0.852 valid_loss 0.016 | lr 5.000000
---------------------------------------------------------------------
| epoch 4 | 50/ 152 batches | train_acc 0.861 train_loss 0.01558
| epoch 4 | 100/ 152 batches | train_acc 0.850 train_loss 0.01815
| epoch 4 | 150/ 152 batches | train_acc 0.844 train_loss 0.01657
---------------------------------------------------------------------
| epoch 4 | time: 1.53s | valid_acc 0.827 valid_loss 0.021 | lr 5.000000
---------------------------------------------------------------------
| epoch 5 | 50/ 152 batches | train_acc 0.893 train_loss 0.01051
| epoch 5 | 100/ 152 batches | train_acc 0.895 train_loss 0.00948
| epoch 5 | 150/ 152 batches | train_acc 0.898 train_loss 0.00814
---------------------------------------------------------------------
| epoch 5 | time: 1.44s | valid_acc 0.890 valid_loss 0.010 | lr 0.500000
---------------------------------------------------------------------
| epoch 6 | 50/ 152 batches | train_acc 0.901 train_loss 0.00764
| epoch 6 | 100/ 152 batches | train_acc 0.905 train_loss 0.00723
| epoch 6 | 150/ 152 batches | train_acc 0.897 train_loss 0.00742
---------------------------------------------------------------------
| epoch 6 | time: 1.58s | valid_acc 0.881 valid_loss 0.009 | lr 0.500000
---------------------------------------------------------------------
| epoch 7 | 50/ 152 batches | train_acc 0.916 train_loss 0.00591
| epoch 7 | 100/ 152 batches | train_acc 0.895 train_loss 0.00736
| epoch 7 | 150/ 152 batches | train_acc 0.906 train_loss 0.00620
---------------------------------------------------------------------
| epoch 7 | time: 1.49s | valid_acc 0.889 valid_loss 0.009 | lr 0.050000
---------------------------------------------------------------------
| epoch 8 | 50/ 152 batches | train_acc 0.914 train_loss 0.00633
| epoch 8 | 100/ 152 batches | train_acc 0.908 train_loss 0.00629
| epoch 8 | 150/ 152 batches | train_acc 0.902 train_loss 0.00630
---------------------------------------------------------------------
| epoch 8 | time: 1.51s | valid_acc 0.889 valid_loss 0.009 | lr 0.005000
---------------------------------------------------------------------
| epoch 9 | 50/ 152 batches | train_acc 0.906 train_loss 0.00662
| epoch 9 | 100/ 152 batches | train_acc 0.913 train_loss 0.00653
| epoch 9 | 150/ 152 batches | train_acc 0.908 train_loss 0.00572
---------------------------------------------------------------------
| epoch 9 | time: 1.63s | valid_acc 0.890 valid_loss 0.009 | lr 0.000500
---------------------------------------------------------------------
| epoch 10 | 50/ 152 batches | train_acc 0.905 train_loss 0.00644
| epoch 10 | 100/ 152 batches | train_acc 0.915 train_loss 0.00594
| epoch 10 | 150/ 152 batches | train_acc 0.907 train_loss 0.00648
---------------------------------------------------------------------
| epoch 10 | time: 1.48s | valid_acc 0.890 valid_loss 0.009 | lr 0.000050
---------------------------------------------------------------------
test_acc, test_loss = evaluate(valid_dataloader)
print('模型准确率为：{:5.4f}'.format(test_acc))
模型准确率为：0.8897
2.结果可视化
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore") #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100 #分辨率
epochs_range = range(EPOCHS)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, total_val_acc, label='Val Accuracy')
plt.legend(loc='lower right')
plt.title('Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, total_val_loss, label='Val Loss')
plt.legend(loc='upper right')
plt.title('Validation Loss')
plt.show()
代码运行结果输出
- 测试指定数据
def predict(text, text_pipeline):
with torch.no_grad():
text = torch.tensor(text_pipeline(text), dtype=torch.float32)
print(text.shape)
output = model(text)
return output.argmax(1).item()
# ex_text_str = "随便播放一首专辑阁楼里的佛里的歌"
ex_text_str = "还有双鸭山到淮阴的汽车票吗13号的"
model = model.to("cpu")
print("该文本的类别是：%s" %label_name[predict(ex_text_str, text_pipeline)])
代码输出
torch.Size([1, 100])
该文本的类别是：Travel-Query
