自然语言处理NLP TextRNN实现情感分类

目录

• 概要
• 数据集
• 数据预处理
• 模型构建
• 模型训练
• 模型评估
• 结论

概要

在自然语言处理（NLP）领域，情感分析及分类是一项十分热门的任务。它的目标是从文本中提取出情感信息和意义，通常分为两类：正向情感和负向情感，并且可以细化为多个情感级别。

在这篇文章中，我们将介绍如何使用TextRNN（Text Recurrent Neural Network)来实现情感短文本分类任务。我们将探索数据预处理、模型构建、训练和评估等主题。

数据集

我们将使用公开的中文情感分类数据集THUCNews。该数据集包括74000个样本，被标记成10个类别：'体育', '娱乐', '家居', '房产', '教育', '时尚', '时政', '游戏', '科技'和 '财经'。我们选择其中5类并按照“csv”格式存储下来：'体育', '时政', '科技', '娱乐'和‘财经’。每个样本由一条短文本和一个标签组成。

以下是读取数据集和预览样本：

import pandas as pd
# 加载数据集
df = pd.read_csv('data.csv')
# 打印前五个样本
print(df.head())

输出：

数据预处理

首先，将文本转换为可供模型使用的数字特征向量是自然语言处理任务中的关键步骤。我们可以通过利用一种称为“分词&cSwpfqzKtrdquo;的技术，将文本划分为一个个单词或词汇。

对于中文文本，我们将使用jieba分词库。以下是代码实现：

import jieba
# 进行中文分词，并将结果以字符串列表形式返回
def chinese_word_cut(mytext):
    return ' '.join(jieba.cut(mytext))
df['www.devze.comtext'] = df.text.apply(chinese_word_cut)

接下来，我们需要将文本数据转换为数值特征向量。我们可以使用torchtext库来处理此操作。以下是代码实现：

import torchtext
from torchtext import data
# 构建Field和Dataset
text_field = data.Field(tokenize='spacy', BATch_first=True, fix_length=100)
label_field = data.LabelField(dtype=torch.long)
fields = [('text', text_field), ('label', label_field)]
dataset = data.TabularDataset(path='data.csv',
                              format='csv',
                              fields=fields,
                              skip_header=True)
# 划分测试集与训练集，比例为0.8/0.2
train_data, test_data = dataset.split(split_ratio=0.8, random_state=random.getstate())
# 构建词典
text_field.build_vocab(train_data, vectors='glove.6B.100d')
label_field.build_vocab(train_data)

在这里，我们定义两个Field：第一个用于表示问题文本，第二个用于表示标签。然后，我们将它们放到一个名为“fields”的列表里。数据的格式是CSV，并由TabularDataset加载。

接着，我们对原始数据进行划分，将80％的数据作为训练集，20％作为测试集。为了能再次处理相同的数据，我们还设置了一个种子(random state)。

最后，我们创建了单词表，并利用预训练的词向量(fill-vectors)进行初始化。例如，在此处，我们选择了GloVe词向量(glove.6B.100d)。GloVe是一种基于全局词频的词向量。

模型构建

TextRNN 是一个典型的循环神经网络模型，专门用于处理序列数据。当我们连续阅读一篇文章时，记忆通常从前到后流动，并且在阅读新的单词时，信息会累积起来，这正是RNN的目标。

我们将使用PyTorch来实现一个简单的TextRNN模型。以下是代码实现：

import torch.nn as nn
class TextRNN(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim, n_layers,
                 bidirectional, dropout):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim) 
        self.hidden_dim = hidden_dim
        self.n_layers = n_layersandroid
        self.bidirectional = bidirectional
        self.rnn = nn.RNN(embed_dim,
                          hidden_dim,
                          num_layers=n_layers,
                          bidirectional=bidirec编程客栈tional,
                          batch_first=True,
                          dropout=dropout)
        self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, text):        
        embedded = self.embedding(text)
        output, hidden = self.rnn(embedded)
        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1))
        return self.fc(hidden)

在RNN层之后有两个线性层：一个用于投影输出空间，一个用于产生最终结果。为了避免过拟合，我们还添加了一些丢弃层。

此处的输入特征为嵌入(embedding)矩阵，该矩阵是固定大小的，其中每行对应于词汇表中的单个单词。所以第一个参数为vocab_size, 第二个参数用于指定分词后每个单词的维度。

RNN的隐藏状态(h)对于这类任务非常关键，因为它是从之前的时间步的信息生成的，并存储了读取所有历史记录的能力。在我们的示例中，我们选用GPU加速训练。

模型训练

现在我们准备好训练模型了。我们将使用PyTorch Lightning框架来加速开发和调试的过程。

以下是代码实现：

import torch
from torch.utils.data import DataLoader
import pytorch_lightning as pl
class Model(pl.LightningModule):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim, n_layers,
                 bidirectional, dropout=0.5):
        super(Model, self).__init__()
        self.rnn = TextRNN(vocab_size, embed_dim, hidden_dim, 
                           out编程客栈put_dim, n_layers, bidirectional, dropout)
        self.loss_fn = nn.CrossEntropyLoss()
    def forward(self, text):
        return self.rnn(text)
    def training_step(self, batch, batch_idx):
        x, y = batch.text, batch.label
        pred_y = self(x).squeeze(1)
        loss = self.loss_fn(pred_y, y)
        acc = accuracy(pred_y, y)
        self.log('train_loss', loss, prog_bar=True)
        self.log('train_acc', acc, prog_bar=True)
        return {'loss': loss}
    def validation_step(self, batch, batch_idx):
        x, y = batch.text, batch.label
        pred_y = self(x).squeeze(1)
        loss = self.loss_fn(pred_y, y)
        acc = accuracy(pred_y, y)
        self.log('val_loss', loss, prog_bar=True)
        self.log('val_acc', acc, prog_bar=True)
  开发者_JAVA教程  def configure_optimizers(self):
        optimizer = torch.optim.Adam(self.parameters(), lr=0.001)
        return optimizer
def accuracy(preds, y):
    _, preds = torch.max(preds, dim=1)
    correct = (preds == y).float()
    acc = correct.sum() / len(correct)
    return acc

这里我们使用LightningModule来创建一个PyTorch Lightning模型。在训练步骤中，我们计算了损失和准确率，并将值记录为train_loss、train_acc、val_loss和 val_acc。然后我们返回损失并将PyTorch Lightning接收到的优化器作为return语句输出。

模型评估

现在我们已经完成了训练，下一步是评估我们的模型。我们将使用测试集进行评估。以下是代码实现：

test_loader = DataLoader(test_data, batch_size=BATCH_SIZE)
ckpt = pl.callbacks.ModelCheckpoint(monitor='val_loss')
trainer = pl.Trainer(gpus=1, callbacks=[ckpt])
model = Model(len(text_field.vocab), 100, 128, len(label_field.vocab), 1, True)
trainer.fit(model, DataLoader(train_data, batch_size=BATCH_SIZE))
trainer.test(test_dataloaders=test_loader) 

在这里，我们将batch size设置为128，并训练20个epoch。最后，使用测试数据评估模型的性能。

结论

在本文章中，我们介绍了如何使用TextRNN模型来实现短文本情感分类任务。我们使用PyTorch和PyTorch Lightning库建立、训练和评估模型。

虽然我们主要关注情感分类任务，但这些方法本质上可以应用于其他NLP问题。

以上就是自然语言处理NLP TextRNN实现情感分类的详细内容，更多关于NLP TextRNN情感分类的资料请关注我们其它相关文章！