NLP TextRNN怎么实现情感分类

这篇文章主要介绍“NLP TextRNN怎么实现情感分类”，在日常操作中，相信很多人在NLP TextRNN怎么实现情感分类问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”NLP TextRNN怎么实现情感分类”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

概要

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

数据集

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

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

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

输出：

数据预处理

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

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

import jieba
# 进行中文分词，并将结果以字符串列表形式返回
def chinese_word_cut(mytext):
    return ' '.join(jieba.cut(mytext))
df['text'] = 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_layers
        self.bidirectional = bidirectional
        self.rnn = nn.RNN(embed_dim,
                          hidden_dim,
                          num_layers=n_layers,
                          bidirectional=bidirectional,
                          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, 
                           output_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)
    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。最后，使用测试数据评估模型的性能。

到此，关于“NLP TextRNN怎么实现情感分类”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注捷杰建站网站，小编会继续努力为大家带来更多实用的文章！