N8 - 使用Word2Vec进行文本分类

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

---

---

由于K同学调整了目录，本来这应该是N6，现在是N8了，中间增加了两节内容，在这里一并打卡了。

N2 构建词典

其实在前面的章节打卡中，也涉及到了构建词典，但是没有一个完整的顺序，这节把构建词典的过程详细的梳理了一下。

1. 导入数据

使用自定义的数据，我直接从网络小说里面截取一段出来。然后按句拆开放到一个列表里。

# 数据
data = [
    "我这才想起今天的米彩在上海参加了一天的商务会谈，后又不顾疲惫来酒吧救场，心中除了感谢更过意不去。",
    "CC推了推我说道：“昭阳，你不送送米儿吗？”",
    "我赶忙点头说道：“嗯，我送她出去。”说着便从米彩手中接过手提包帮她提着。",
    "米彩说了声“谢谢”后在我之前向酒吧外走去，我跟上了她说道：“你老和我说谢谢，弄得我们之间多生分吶！”",
    "“有吗？”"
    "米彩心不在焉的回答，让我无从去接她的话，只是在沉默中跟着她的脚步向外面走着。",
    "忽然我们的脚步止于酒吧外面的屋檐下，此刻天空竟然飘起了漫天的雪花，这个冬天终于下雪了。",
    "我下意识的感叹，道：“下雪了！”",
    "“嗯！”米彩应了一声，却比我更会珍惜这样的画面，从手提包里拿出卡片相机将眼前银装素裹的世界定格在了镜头里，然后离开屋檐，走进了漫天的雪花中。"
]
# 把人名弄成自定义字典
user_dictionary = [
    "CC", "昭阳","米儿", "米彩"
]

2. 设置分词器

import jieba
tokenizer = jieba.lcut
jieba.load_userdict(user_dictionary)

3. 去除标点和停用词

编写一个过滤函数去除标点符号

import re
def remove_punctuation(text):
	return re.sub(r'[^\w\s]', '', text)

维护一个停用词列表,编写停用词过滤函数

stopwords = ['的', '这', '是']
def remove_stopwords(words):
	return [word for word in words if word not in stopwords]

4. 文本迭代器

编写一个迭代器，将文本转化成返回单词

def yield_tokens(data_iter):
	for text in data_iter:
		# 去除标点符号
		text = remove_punctuation(text)
		# 分词
		words = tokenizer(text)
		# 去除停用词
		words = remove_stopwords(words)
		yield words

5. 构建词典

from torchtext.vocab import build_vocab_from_iterator
# 遍历所有的分词结果，构建词典
vocab = build_vocab_from_iterator(yield_tokens(data), specials=['<unk>'])

# 将未知的词汇设置为<unk>
vocab.set_default_index(vocab['<unk>'])

build_vocab_from_iterator用来从一个可迭代对象中统计token的频次，并返回一个词典
它的原型如下

def build_vocab_from_iterator(iterator: Iterable,
							  min_freq: int = 1,
							  specials: Optional[List[str]] = None,
							  special_first: bool = True,
							  max_tokens: Optional[int] = None
							  )

参数解释如下：

• iterator: 用于创建词典的可迭代对象
• min_freq: 最小频数，文本中的词汇只有频数大于min_freq的才会保留下来，出现在词典中
• specials: 特殊标志，值是一个字符串的列表。用于在词典中添加一些特殊的token，例如我们使用<unk>来代表字典中不存在的token。
• special_first: 表示是否将special token放在词典顺序的最前面（也就是Index小），默认是True
• max_tokens: 限制词典词汇的最大数量

备注：除了special_token之外的token是按词频来降序排列的，如果两个词的频次一样，则按出现顺序。
set_default_index可以设置默认使用的token,比如添加一个<unk>设置为默认。

6. 文本数字化

# 打印词典中的内容
print('词典大小:', len(vocab))
print('词典内部映射:', vocab.get_stoi())

text = "外面是冬天"
words = remove_stopwords(jieba.lcut(text))
print()
print('jieba分词后的文本:', jieba.lcut(text))
print('去除停用词后的文本:', words)
print('数字化后的文本:', [vocab[word] for word in words])

N3 NLP中的数据集构建

torch.utils.data 是pytorch中用于数据加载和预处理的模块，其中包含Dataset和DataLoader两个类，通常结合使用来加载和处理数据。

1. Dataset

torch.utils.data.Dataset是一个抽象类，用于表示数据集。

自定义Dataset需要继承这个基类，并实现两个方法__len__和__getitem__

其中__len__返回的是数据集的大小，__getitem__用于根据索引返回一个数据样本。

自定义一个数据集的示例

from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts = texts
        self.labels = labels

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        texts = self.texts[idx]
        labels = self.labels[idx]
        return texts, labels

2. DataLoader

torch.utils.data.DataLoader是pytorch中一个重要的类，用于高效的加载数据集。它可以将数据批次化、打乱数据的顺序、多线程加载数据等。

import torch
from torch.utils.data import DataLoader
# 假数据
text_data = [
	torch.tensor([1, 2, 3, 4], dtype=torch.long),
	torch.tensor([4, 3, 2], dtype=torch.long),
	torch.tensor([1, 2], dtype=torch.long)
]
text_labels = torch.tensor([1, 0, 1], dtype=torch.float)

# 创建dataset
my_dataset = MyDataset(text_data, text_labels)
# 通过dataset创建dataloader
dataloader = DataLoader(my_dataset, batch_size=2, shuffle=True, collate_fn=lambda x: x)

# 打印一下dataloader里面的数据
for batch in dataloader:
	print(batch)

重复执行几次，可以看到batch中的数据是随机的，没有固定的顺序

N8 使用Word2Vec进行文本分类

Word2Vec是一种用于生成词向量的浅层神经网络模型，由Tomas Mikolov及其团队于2013年提出。Word2Vec通过学习大量的文本数据，将每个单词表示为一个连续的向量，这些向量可以捕捉单词之间的主义和句法关系。上一节的打卡中，我们使用gensim在一篇小说内容上训练了一个Word2Vec模型。

这节我们训练一个word2vec模型，并用它来做文本分类任务。

环境设置

创建全局的torch device

import torch
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

数据准备

使用pandas读取csv

import pandas as pd

# 读取当前目录下的train.csv，里面的数据按\t分隔，并且没有表头
data = pd.read_csv('train.csv', sep='\t', header=None)
data.head()

拆分数据中的文本和标签

data_x = data[0].values[:]
data_y = data[1].values[:]

创建并训练word2vec模型

from gensim.models.word2vec import Word2Vec

# 创建一个输出向量为100维的word2vec模型，并且忽略词频小于3的单词
w2v = Word2Vec(vector_size=100, min_count=3)
# 使用数据集构建词典
w2v.build_vocab(data_x)
# 训练word2vec模型,文本数量使用上一步统计的输入文本数量(total_examples=w2v.corpus_count)，训练20轮(epochs=20)
w2v.train(data_x, total_examples=w2v.corpus_count, epochs=20)

现在word2vec模型已经训练好了，我们直接把csv中的所有数据跑一下，让文本数据集变成向量数据集

import numpy as np
import os
# 把一段文本转换成向量，将其中的所有单词向量相加
def text_vector(text):
	vec = np.zeros((1, 100))
	for word in text:
		try:
			# 因为词频小于3的单词忽略了，所有会有找不到key的异常抛出这里直接try了忽略掉
			vec += w2v.wv[word].reshape((1, 100))
		except KeyError:
			continue
	return vec

# 把x转换为向量的x
vec_x = torch.concatenate([text_vector(text) for text in data_x])

# 保存word2vec模型
if not os.path.exists('model'):
	os.makedirs('model', exist_ok=True)
w2v.save('model/w2v_model.pkl')

编写一个迭代函数，把x和y组合到一起

def yield_zip_iter(data_x, data_y):
	for x, y in zip(data_x, data_y):
		yield x, y

取出所有的分类名，用于将分类标签转成索引

label_names = list(set(data_y))
label_names

标签文本转索引的函数

label_pipeline = lambda y: label_names.index(y)
label_pipeline('Travel-Query')

编写批次数据的整理函数，用于把一个批次原本的形状如[(x1,y1), (x2,y2)]的数据转换为[x1,x2]和[y1, y2]

def collate_batch(batch):
	data_list, label_list = [], []
	for x, y in batch:
		data_list.append(torch.tensor(x, dtype=torch.float32))
		label_list.append(label_pipeline(y))
	#转为tensor
	data_list = torch.stack(data_list)
	label_list = torch.tensor(label_list, dtype=torch.int64)
	return data_list.to(device), label_list.to(device)

生成数据集

from torchtext.utils import to_map_style_dataset
from torch.utils.data import random_split

# 创建数据迭代器
data_iter = yield_zip_iter(vec_x , data_y)
# 把迭代器转成dataset
train_dataset = to_map_style_dataset(data_iter)

# 拆分dataset为训练和验证
train_size = int(len(train_dataset) * 0.8)
train_split = random_split(train_dataset, [train_size, len(train_dataset) - train_size])

模型设计

创建torch模型，只有一层简单的全连接就可以，只有一层全连接准确度不达标，增加一层bottleneck提升准确率

import torch.nn as nn

class TextClassificationModel(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        self.fc = nn.Sequential(nn.Linear(100, 64),nn.ReLU(), nn.Linear(64, num_classes)) 

    def forward(self, x):
        return self.fc(x)

model = TextClassificationModel(len(label_names)).to(device)

模型训练

编写模型训练函数

# 编写训练函数
import time

def train(dataloader):
    model.train()
    train_acc, train_loss, total_count = 0, 0, 0
    log_interval = 50
    start_time = time.time()

    for idx, (vector, label) in enumerate(dataloader):
        # 前向传播
        predicted_label = model(vector)

        # 反向传播
        optimizer.zero_grad()
        loss = criterion(predicted_label, label)
        loss.backward()
        nn.utils.clip_grad_norm_(model.parameters(), 0.1) # 梯度裁剪
        optimizer.step()

        # 记录数据
        train_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), train_acc/total_count, train_loss/total_count))
            train_acc, train_acc, total_count = 0, 0, 0
            start_time = time.time()

def evaluate(dataloader):
    model.eval()
    total_acc, total_loss, total_count = 0, 0, 0
    with torch.no_grad():
        for idx, (vector, label) in enumerate(dataloader):
            predicted_label = model(vector)

            loss = criterion(predicted_label, label)
            # 记录数据
            total_acc += (predicted_label.argmax(1) == label).sum().item()
            total_loss += loss.item()
            total_count += label.size(0)

    return total_acc / total_count, total_loss / total_count

开始训练

from torch.utils.data import DataLoader
# 超参数
epochs = 10
lr = 5
batch_size = 64

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.1)
total_acc = None

train_dataloader = DataLoader(split_train, batch_size=batch_size, shuffle=True, collate_fn=collate_batch)
valid_dataloader = DataLoader(split_valid, batch_size, shuffle=True, collate_fn=collate_batch)

acc_history, loss_history = [], []

# 训练
for epoch in range(1, epochs+1):
	epoch_start_time = time.time()
    train(train_dataloader)
    val_acc, val_loss = evaluate(valid_dataloader)
    acc_history.append(val_acc)
    loss_history.append(val_loss)
    
    lr = optimizer.state_dict()['param_groups'][0]['lr']
    if total_acc is not None and total_acc > val_acc:
        scheduler.step()
    else:
        total_acc = 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)

训练结束后打印一下模型最后的准确率

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

模型效果展示

编写一个用来预测的函数，输入文本，输出标签

def predict(text):
    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_names[predict(ex_text_str)])

可以发现结果是正确的

画一下训练过程的数据曲线

import matplotlib.pyplot as plt
ranges = list(range(1, epochs+1))

plt.title('Validation Accuracy')
plt.plot(ranges, acc_history, label='Accuracy')

plt.title('Validation Loss')
plt.plot(ranges, loss_history, label='Loss')

总结与心得体会

通过对新增的两个章节的回顾和本章的任务的训练，让我印象最深刻的就是to_map_style_dataset这个函数的使用。通过它把一个简单的yield函数变成了数据集，具体的dataset不需要自己来实现，这样做的好处是非常快捷。但是这种方式应该仅限于数据量不大的情况下使用，如果数据量太大，它会全部加载到内存中，这时候就应该使用自定义的数据集，通过索引来进行取数据，具体的逻辑更加灵活，不用在没有训练的时候就把数据加载到内存里。
还有就是使用word2vec来实现文本分类任务的过程，开始看到这个下意识的认为需要用pytorch重写一个word2vex模型，最后发现完全可以使用不同的库组合进来达到最终的目的。