N4、使用Word2vec实现文本分类

cauwj / 2023-05-19 / 原文

🍨 本文为🔗365天深度学习训练营中的学习记录博客

🍖 原作者：K同学啊 | 接辅导、项目定制

📌 本周任务： ● 结合Word2Vec文本内容（第1列）预测文本标签（第2列） ● 尝试根据第2周的内容独立实现，尽可能的不看本文的代码 ● 进一步了解并学习Word2Vec

任务说明 本次将加入Word2vec使用PyTorch实现中文文本分类，Word2Vec 则是其中的一种词嵌入方法，是一种用于生成词向量的浅层神经网络模型，由Tomas Mikolov及其团队于2013年提出。Word2Vec通过学习大量文本数据，将每个单词表示为一个连续的向量，这些向量可以捕捉单词之间的语义和句法关系。

数据示例如下：

一、数据预处理¶

1、加载数据¶

In [1]:

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

Out[1]:

device(type='cuda')

In [2]:

import pandas as pd

# 加载自定义中文数据
train_data = pd.read_csv('./data/N4.csv', sep='\t', header=None)
train_data.head()

Out[2]:

	0	1
0	还有双鸭山到淮阴的汽车票吗13号的	Travel-Query
1	从这里怎么回家	Travel-Query
2	随便播放一首专辑阁楼里的佛里的歌	Music-Play
3	给看一下墓王之王嘛	FilmTele-Play
4	我想看挑战两把s686打突变团竞的游戏视频	Video-Play

In [3]:

# 构造数据集迭代器
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[:]

zip 是 Python 中的一个内置函数，它可以将多个序列（列表、元组等）中对应的元素打包成一个个元组，然后返回这些元组组成的一个迭代器。例如，在代码中 zip(texts, labels) 就是将 texts 和 labels 两个列表中对应位置的元素一一打包成元组，返回一个迭代器，每次迭代返回一个元组 (x, y)，其中 x 是 texts 中的一个元素，y 是 labels 中对应的一个元素。这样，每次从迭代器中获取一个元素，就相当于从 texts 和 labels 中获取了一组对应的数据。在这里，zip 函数主要用于将输入的 texts 和 labels 打包成一个可迭代的数据集，然后传给后续的模型训练过程使用。

2. 构建词典¶

需要另外安装gensim，安装语句pip install gensim

In [4]:

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)

Out[4]:

(2732953, 3663560)

Word2Vec可以直接训练模型，一步到位。这里分了三步

第一步构建一个空模型
第二步使用 build_vocab 方法根据输入的文本数据 x 构建词典。build_vocab 方法会统计输入文本中每个词汇出现的次数，并按照词频从高到低的顺序将词汇加入词典中。
第三步使用 train 方法对模型进行训练，total_examples 参数指定了训练时使用的文本数量，这里使用的是 w2v.corpus_count 属性，表示输入文本的数量

如果一步到位的话代码为：

w2v = Word2Vec(x, vector_size=100, min_count=3, epochs=20)

In [5]:

# 将文本转化为向量
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('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 中元素的数量。

In [6]:

train_iter = coustom_data_iter(x_vec, y)

In [7]:

len(x),len(x_vec)

Out[7]:

(12100, 12100)

In [8]:

label_name = list(set(train_data[1].values[:]))
print(label_name)

['Alarm-Update', 'Weather-Query', 'Other', 'Radio-Listen', 'Audio-Play', 'Music-Play', 'Calendar-Query', 'TVProgram-Play', 'Travel-Query', 'Video-Play', 'FilmTele-Play', 'HomeAppliance-Control']

3.生成数据批次和迭代器¶

In [9]:

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 列表中的索引。这个函数可以用于将原始标签数据转换为数字索引表示的形式。

In [10]:

text_pipeline("你在干嘛")

Out[10]:

array([[-0.4240898 ,  2.15416817,  1.64407132, -0.25945155, -1.82393508,
         0.26936458,  1.80384278,  0.75011735,  0.44621134,  0.75236849,
        -1.80496462, -4.15242571,  0.95589581, -0.88259695,  1.16369125,
         1.25188963,  2.56563786, -1.67390999,  4.26177543, -0.18189707,
         2.77255061,  0.15863885,  0.38612834,  0.13551027, -1.29756263,
        -0.20521596, -0.99651097, -1.77489951,  1.66571844, -0.97035506,
         1.90100314,  1.51176031, -1.12018394, -0.32226303,  0.07748781,
        -0.06989229, -0.11033055,  3.86311503, -1.5566606 ,  1.10823553,
        -0.23345399, -0.27460822, -0.01498471,  0.72437063, -1.23045968,
         0.42955365,  0.75161904, -1.23005864, -2.43768139,  2.2552066 ,
        -0.06995412, -1.88907828, -1.27520892,  0.55803251, -0.64900192,
        -0.45648068,  0.14907199, -0.39127199, -1.23329519,  1.20207857,
         1.25359552, -1.82598262,  2.36248075, -0.68842094, -0.26018263,
         0.0921493 , -1.06243694,  1.27780351,  1.13570974,  0.56780273,
        -0.07599387,  0.42166517,  1.62252279, -0.67768769,  0.49317535,
        -0.19895933, -3.72679655,  0.73324186,  1.33566724, -0.30264652,
        -1.7993039 , -0.27138549, -2.47578481,  1.7430429 , -2.72991388,
        -0.97202597,  1.69158333, -1.31190498, -0.03804862, -0.01617371,
         0.58824495, -1.51250622,  1.13584472,  0.8537136 ,  0.91943032,
        -2.61209362, -0.37564262,  1.41787986, -2.67349243,  0.59493251]])

In [11]:

label_pipeline("Travel-Query")

Out[11]:

In [12]:

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)

二、模型构建¶

1.搭建模型¶

In [13]:

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)

2.初始化模型¶

In [14]:

num_class  = len(label_name)
vocab_size = 100000
em_size    = 12
model      = TextClassificationModel(num_class).to(device)

3.定义训练与评估函数¶

In [15]:

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）中。当梯度爆炸时，参数更新可能会变得非常大，导致模型无法收敛或出现数值不稳定。通过限制梯度的大小，梯度裁剪有助于解决这些问题，使模型训练变得更加稳定。

三、训练模型¶

1. 拆分数据集并运行模型¶

In [16]:

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    = 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)

for epoch in range(1, EPOCHS + 1):
    epoch_start_time = time.time()
    train(train_dataloader)
    val_acc, val_loss = evaluate(valid_dataloader)
    
    # 获取当前的学习率
    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.749 train_loss 0.02339
| epoch 1 |  100/ 152 batches | train_acc 0.827 train_loss 0.01889
| epoch 1 |  150/ 152 batches | train_acc 0.829 train_loss 0.01917
---------------------------------------------------------------------
| epoch 1 | time: 2.73s | valid_acc 0.764 valid_loss 0.034 | lr 5.000000
---------------------------------------------------------------------
| epoch 2 |   50/ 152 batches | train_acc 0.845 train_loss 0.01688
| epoch 2 |  100/ 152 batches | train_acc 0.852 train_loss 0.01588
| epoch 2 |  150/ 152 batches | train_acc 0.838 train_loss 0.01815
---------------------------------------------------------------------
| epoch 2 | time: 0.59s | valid_acc 0.821 valid_loss 0.021 | lr 5.000000
---------------------------------------------------------------------
| epoch 3 |   50/ 152 batches | train_acc 0.853 train_loss 0.01558
| epoch 3 |  100/ 152 batches | train_acc 0.858 train_loss 0.01674
| epoch 3 |  150/ 152 batches | train_acc 0.854 train_loss 0.01768
---------------------------------------------------------------------
| epoch 3 | time: 0.64s | valid_acc 0.837 valid_loss 0.023 | lr 5.000000
---------------------------------------------------------------------
| epoch 4 |   50/ 152 batches | train_acc 0.847 train_loss 0.01623
| epoch 4 |  100/ 152 batches | train_acc 0.867 train_loss 0.01564
| epoch 4 |  150/ 152 batches | train_acc 0.851 train_loss 0.01593
---------------------------------------------------------------------
| epoch 4 | time: 0.73s | valid_acc 0.854 valid_loss 0.020 | lr 5.000000
---------------------------------------------------------------------
| epoch 5 |   50/ 152 batches | train_acc 0.854 train_loss 0.01666
| epoch 5 |  100/ 152 batches | train_acc 0.853 train_loss 0.01703
| epoch 5 |  150/ 152 batches | train_acc 0.860 train_loss 0.01646
---------------------------------------------------------------------
| epoch 5 | time: 0.63s | valid_acc 0.809 valid_loss 0.032 | lr 5.000000
---------------------------------------------------------------------
| epoch 6 |   50/ 152 batches | train_acc 0.890 train_loss 0.01066
| epoch 6 |  100/ 152 batches | train_acc 0.903 train_loss 0.00864
| epoch 6 |  150/ 152 batches | train_acc 0.895 train_loss 0.00903
---------------------------------------------------------------------
| epoch 6 | time: 0.83s | valid_acc 0.881 valid_loss 0.012 | lr 0.500000
---------------------------------------------------------------------
| epoch 7 |   50/ 152 batches | train_acc 0.898 train_loss 0.00829
| epoch 7 |  100/ 152 batches | train_acc 0.907 train_loss 0.00673
| epoch 7 |  150/ 152 batches | train_acc 0.908 train_loss 0.00726
---------------------------------------------------------------------
| epoch 7 | time: 0.81s | valid_acc 0.877 valid_loss 0.011 | lr 0.500000
---------------------------------------------------------------------
| epoch 8 |   50/ 152 batches | train_acc 0.904 train_loss 0.00702
| epoch 8 |  100/ 152 batches | train_acc 0.915 train_loss 0.00592
| epoch 8 |  150/ 152 batches | train_acc 0.909 train_loss 0.00640
---------------------------------------------------------------------
| epoch 8 | time: 1.10s | valid_acc 0.881 valid_loss 0.011 | lr 0.050000
---------------------------------------------------------------------
| epoch 9 |   50/ 152 batches | train_acc 0.909 train_loss 0.00631
| epoch 9 |  100/ 152 batches | train_acc 0.917 train_loss 0.00594
| epoch 9 |  150/ 152 batches | train_acc 0.906 train_loss 0.00669
---------------------------------------------------------------------
| epoch 9 | time: 0.98s | valid_acc 0.880 valid_loss 0.011 | lr 0.050000
---------------------------------------------------------------------
| epoch 10 |   50/ 152 batches | train_acc 0.914 train_loss 0.00661
| epoch 10 |  100/ 152 batches | train_acc 0.910 train_loss 0.00601
| epoch 10 |  150/ 152 batches | train_acc 0.908 train_loss 0.00597
---------------------------------------------------------------------
| epoch 10 | time: 0.84s | valid_acc 0.880 valid_loss 0.011 | lr 0.005000
---------------------------------------------------------------------

In [17]:

test_acc, test_loss = evaluate(valid_dataloader)
print('模型准确率为：{:5.4f}'.format(test_acc))

模型准确率为：0.8798

2. 测试指定数据¶

In [18]:

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