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

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

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

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)

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)

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

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)