使用 PyTorch 进行自然语言处理

2020-06-24 08:00:00 · 飞浪

介绍自然语言处理是数据科学和人工智能的一个大领域。它包括多种应用，例如情绪分析、机器翻译、语音识别、聊天机器人创建、市场情报和文本分类。PyTorch是一个流行且功能强大的深度学习库，

介绍

自然语言处理是数据科学和人工智能的一个大领域。它包括多种应用，例如情绪分析、机器翻译、语音识别、聊天机器人创建、市场情报和文本分类。PyTorch是一个流行且功能强大的深度学习库，具有执行自然语言处理任务的丰富功能。在本指南中，您将探索和学习使用PyTorch进行文本分类的自然语言处理技术。

数据和所需库

首先，加载所需的库。您要导入的第一个包是torch库，它用于定义张量并执行数学运算。要导入的第二个库是torchtext库，它是 PyTorch 中的 NLP 库，其中包含数据处理实用程序。

      import torch
import torchtext
    

下一步是加载数据集。torchtext库包含模块torchtext.data ，该模块有多个数据集可用于执行自然语言处理任务。在本指南中，您将使用内置的SogouNews数据集进行文本分类。这是一个监督学习新闻数据集，有五个标签：0代表体育，1代表金融，2代表娱乐，3代表汽车，4代表科技。

下面的代码行加载数据集。设置NGRAMS = 2将确保数据集中的文本将是单个单词加二元词串的列表。

      from torchtext.datasets import text_classification
NGRAMS = 2
import os
if not os.path.isdir('./.data'):
    os.mkdir('./.data')
train_dataset, test_dataset = text_classification.DATASETS['SogouNews'](
    root='./.data', ngrams=NGRAMS, vocab=None)
BATCH_SIZE = 16
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    

输出：

      sogou_news_csv.tar.gz: 384MB [00:04, 94.7MB/s] 
450000lines [08:18, 902.49lines/s] 
450000lines [17:33, 427.10lines/s] 
60000lines [02:19, 428.77lines/s]
    

您已经加载了数据，下一步是设置模型架构。

模型架构

该模型架构由一个嵌入层和一个线性层组成。nn.EmbeddingBag函数计算一袋嵌入的平均值（无填充），因为文本长度保存在偏移量中。

下面的前两行代码导入了所需的模块。下一步是在nn.Module中实现TextSentiment()模型类，这是通过第三行代码完成的。

然后，使用__init__()方法设置架构。__ init__()方法下的self参数表示对象本身的实例。参数vocab_size表示词汇表的大小，默认值为 20,000。参数embed_dim表示词嵌入的维度。num_class参数表示目标变量中的类数。

您已经定义了层，但您还需要定义它们如何相互作用。这是通过def forward()函数完成的。简而言之，这意味着您以正向方式从输入到输出。

      import torch.nn as nn
import torch.nn.functional as F
class TextSentiment(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super().__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=True)
        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)
    

模型架构已设置好，下一步是定义上面讨论的将在模型构建中使用的重要参数。这可以通过以下代码完成。

      VOCAB_SIZE = len(train_dataset.get_vocab())
EMBED_DIM = 32
NUN_CLASS = len(train_dataset.get_labels())
model = TextSentiment(VOCAB_SIZE, EMBED_DIM, NUN_CLASS).to(device)
    

批次生成

数据集中的文本长度各不相同，因此需要编写一个生成数据批次的函数。此任务由以下代码中的generate_batch()函数执行。

      def generate_batch(batch):
    label = torch.tensor([entry[0] for entry in batch])
    text = [entry[1] for entry in batch]
    offsets = [0] + [len(entry) for entry in text]
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
    text = torch.cat(text)
    return text, offsets, label
    

定义训练函数

下一步是定义训练函数。在下面的代码中使用辅助函数def train_func(sub_train_)来执行此操作。

从torch.utils.data实用程序导入DataLoader模块，以便于并行加载数据。主要参数包括：

batch_size：每个批次要加载的样本数量。默认值为 1。
collate_fn：合并张量列表以形成张量的小批量。之前创建的generate_batch函数将成为此参数的输入。

3：shuffle：设置为True表示每次迭代都会重新排列数据。默认选项为False。

您还将创建辅助函数来评估训练和测试数据集。

      from torch.utils.data import DataLoader
def train_func(sub_train_):
    # Train the model
    train_loss = 0
    train_acc = 0
    data = DataLoader(sub_train_, batch_size=BATCH_SIZE, shuffle=True,
                      collate_fn=generate_batch)
    for i, (text, offsets, cls) in enumerate(data):
        optimizer.zero_grad()
        text, offsets, cls = text.to(device), offsets.to(device), cls.to(device)
        output = model(text, offsets)
        loss = criterion(output, cls)
        train_loss += loss.item()
        loss.backward()
        optimizer.step()
        train_acc += (output.argmax(1) == cls).sum().item()

    # Adjust the learning rate
    scheduler.step()

    return train_loss / len(sub_train_), train_acc / len(sub_train_)

def test(data_):
    loss = 0
    acc = 0
    data = DataLoader(data_, batch_size=BATCH_SIZE, collate_fn=generate_batch)
    for text, offsets, cls in data:
        text, offsets, cls = text.to(device), offsets.to(device), cls.to(device)
        with torch.no_grad():
            output = model(text, offsets)
            loss = criterion(output, cls)
            loss += loss.item()
            acc += (output.argmax(1) == cls).sum().item()

    return loss / len(data_), acc / len(data_)
    

模型建立

在构建模型之前，您必须拆分数据，这可以通过torch.utils.data.dataset实用函数中的random_split模块完成。使用随机梯度下降优化器来优化网络，考虑到这是一个分类问题，使用交叉熵作为损失函数。lr 参数指定优化器函数的学习率。最后，打印出epochs性能和所用时间。

      import time
from torch.utils.data.dataset import random_split
N_EPOCHS = 5
min_valid_loss = float('inf')

criterion = torch.nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=4.0)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)

train_len = int(len(train_dataset) * 0.95)
sub_train_, sub_valid_ = \
    random_split(train_dataset, [train_len, len(train_dataset) - train_len])

for epoch in range(N_EPOCHS):

    start_time = time.time()
    train_loss, train_acc = train_func(sub_train_)
    valid_loss, valid_acc = test(sub_valid_)

    secs = int(time.time() - start_time)
    mins = secs / 60
    secs = secs % 60

    print('Epoch: %d' %(epoch + 1), " | time in %d minutes, %d seconds" %(mins, secs))
    print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)')
    print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')
    

输出：

      Epoch: 1  | time in 18 minutes, 17 seconds
	Loss: 0.0128(train)	|	Acc: 93.8%(train)
	Loss: 0.0000(valid)	|	Acc: 95.0%(valid)
Epoch: 2  | time in 17 minutes, 59 seconds
	Loss: 0.0080(train)	|	Acc: 96.1%(train)
	Loss: 0.0000(valid)	|	Acc: 95.9%(valid)
Epoch: 3  | time in 18 minutes, 9 seconds
	Loss: 0.0065(train)	|	Acc: 96.8%(train)
	Loss: 0.0000(valid)	|	Acc: 96.3%(valid)
Epoch: 4  | time in 18 minutes, 19 seconds
	Loss: 0.0056(train)	|	Acc: 97.2%(train)
	Loss: 0.0000(valid)	|	Acc: 95.9%(valid)
Epoch: 5  | time in 18 minutes, 17 seconds
	Loss: 0.0048(train)	|	Acc: 97.6%(train)
	Loss: 0.0000(valid)	|	Acc: 96.4%(valid)
    

从上面的输出可以看出，该模型在第五个时期的准确率达到了 97.6%。接下来，在测试数据上评估模型性能。

模型评估

下面的代码行检查测试数据并显示结果。

      print('Model result on test data...')
test_loss, test_acc = test(test_dataset)
print(f'\tLoss: {test_loss:.4f}(test)\t|\tAcc: {test_acc * 100:.1f}%(test)')
    

输出：

      Model result on test data...
	Loss: 0.0000(test)	|	Acc: 96.2%(test)
    

在测试数据上模型准确率为96.2%，与在训练数据上模型表现一致，说明模型取得了良好的效果。

结论

在本指南中，您学习了如何使用高性能深度学习库 PyTorch 构建文本分类模型。您学习了使用PyTorch 的torch和torchtext包构建文本分类算法的架构和关键组件。

要了解有关使用 Python 进行数据科学的更多信息，请参阅以下指南。

_{免责声明：本内容来源于第三方作者授权、网友推荐或互联网整理，旨在为广大用户提供学习与参考之用。所有文本和图片版权归原创网站或作者本人所有，其观点并不代表本站立场。如有任何版权侵犯或转载不当之情况，请与我们取得联系，我们将尽快进行相关处理与修改。感谢您的理解与支持！}

_查看原文

技术指南

阅读全文

使用 PyTorch 进行自然语言处理

杭州电子商务研究院

4年前 · 面向社会、服务行业、政产学研结合、整合资源、和谐发展

from torchtext.datasets import text_classification NGRAMS = 2 import os if not os.path.isdir('./.data'): os.mkdir('./.data') train_dataset, test_dataset = text_classification.DATASETS['SogouNews']( root='./.data', ngrams=NGRAMS, vocab=None) BATCH_SIZE = 16 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

import torch.nn as nn import torch.nn.functional as F class TextSentiment(nn.Module): def __init__(self, vocab_size, embed_dim, num_class): super().__init__() self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=True) 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)

def generate_batch(batch): label = torch.tensor([entry[0] for entry in batch]) text = [entry[1] for entry in batch] offsets = [0] + [len(entry) for entry in text] offsets = torch.tensor(offsets[:-1]).cumsum(dim=0) text = torch.cat(text) return text, offsets, label

from torch.utils.data import DataLoader def train_func(sub_train_): # Train the model train_loss = 0 train_acc = 0 data = DataLoader(sub_train_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch) for i, (text, offsets, cls) in enumerate(data): optimizer.zero_grad() text, offsets, cls = text.to(device), offsets.to(device), cls.to(device) output = model(text, offsets) loss = criterion(output, cls) train_loss += loss.item() loss.backward() optimizer.step() train_acc += (output.argmax(1) == cls).sum().item() # Adjust the learning rate scheduler.step() return train_loss / len(sub_train_), train_acc / len(sub_train_) def test(data_): loss = 0 acc = 0 data = DataLoader(data_, batch_size=BATCH_SIZE, collate_fn=generate_batch) for text, offsets, cls in data: text, offsets, cls = text.to(device), offsets.to(device), cls.to(device) with torch.no_grad(): output = model(text, offsets) loss = criterion(output, cls) loss += loss.item() acc += (output.argmax(1) == cls).sum().item() return loss / len(data_), acc / len(data_)

import time from torch.utils.data.dataset import random_split N_EPOCHS = 5 min_valid_loss = float('inf') criterion = torch.nn.CrossEntropyLoss().to(device) optimizer = torch.optim.SGD(model.parameters(), lr=4.0) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9) train_len = int(len(train_dataset) * 0.95) sub_train_, sub_valid_ = \ random_split(train_dataset, [train_len, len(train_dataset) - train_len]) for epoch in range(N_EPOCHS): start_time = time.time() train_loss, train_acc = train_func(sub_train_) valid_loss, valid_acc = test(sub_valid_) secs = int(time.time() - start_time) mins = secs / 60 secs = secs % 60 print('Epoch: %d' %(epoch + 1), " | time in %d minutes, %d seconds" %(mins, secs)) print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)') print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')