自然語言處理NLP TextRNN實現情感分類

2023-11-02 22:00:12

概要

在自然語言處理（NLP）領域，情感分析及分類是一項十分熱門的任務。它的目標是從文字中提取出情感資訊和意義，通常分為兩類：正向情感和負向情感，並且可以細化為多個情感級別。

在這篇文章中，我們將介紹如何使用TextRNN（Text Recurrent Neural Network)來實現情感短文字分類任務。我們將探索資料預處理、模型構建、訓練和評估等主題。

資料集

我們將使用公開的中文情感分類資料集THUCNews。該資料集包括74000個樣本，被標記成10個類別：'體育', '娛樂', '家居', '房產', '教育', '時尚', '時政', '遊戲', '科技'和 '財經'。我們選擇其中5類並按照“csv”格式儲存下來：'體育', '時政', '科技', '娛樂'和‘財經’。每個樣本由一條短文字和一個標籤組成。

以下是讀取資料集和預覽樣本：

import pandas as pd
# 載入資料集
df = pd.read_csv('data.csv')
# 列印前五個樣本
print(df.head())

輸出：

	label	text
0	3	華彩行動到了20位擔保人全國民間組織網路代表共襄盛舉
1	4	中移動前4月新使用者淨增955萬用戶
2	1	浙江教育房貸減輕購房壓力師生建體制
3	1	中央黨校黨的歷史研究院原副院長林必勝先生逝世
4	1	中央黨校黨的歷史研究院實現640家文博單位軍工企業4000餘名幹部學習實踐十八大精神

資料預處理

首先，將文字轉換為可供模型使用的數位特徵向量是自然語言處理任務中的關鍵步驟。我們可以通過利用一種稱為“分詞”的技術，將文字劃分為一個個單詞或詞彙。

對於中文文字，我們將使用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。最後，使用測試資料評估模型的效能。