使用深度学习做文本情感分类

import torch
from torch import nn
from torch.nn import functional
from torch import optim
from torchtext import data
from torchtext.vocab import Vectors
from tqdm import tqdm
import pandas

def get_dataset(sample_data, id_field, text_field, label_field, test=False):  # 构造并返回Dataset
    fields = [('PhraseId', id_field), ('Phrase', text_field),
              ('Sentiment', label_field)]
    examples = []
    if test:
        for pid, text in tqdm(zip(sample_data['PhraseId'], sample_data['Phrase'])):
            examples.append(data.Example.fromlist([pid, text, None], fields))
    else:
        for pid, text, label in tqdm(zip(sample_data['PhraseId'], sample_data['Phrase'], sample_data['Sentiment'])):
            examples.append(data.Example.fromlist([pid, text, label], fields))
    return data.Dataset(examples, fields)


test_data = pandas.read_csv('datasets/test.tsv', sep='\t',
                            usecols=['PhraseId', 'Phrase'])  # 157451 行有缺失值，手动处理为unk
raw_train_data = pandas.read_csv('datasets/train.tsv', sep='\t', usecols=[
                                 'PhraseId', 'Phrase', 'Sentiment'])  # 2006 行有缺失值，手动处理为unk

# 划分数据
train_data = raw_train_data.sample(frac=0.8, random_state=0, axis=0)
val_data = raw_train_data[~raw_train_data.index.isin(train_data.index)]

# 得到数据集
PID = data.Field(sequential=False, use_vocab=False)
TEXT = data.Field(sequential=True, tokenize=lambda x: x.split(),
                  lower=True, include_lengths=True)
LABEL = data.Field(sequential=False, use_vocab=False)

train = get_dataset(train_data, PID, TEXT, LABEL)
val = get_dataset(val_data, PID, TEXT, LABEL)
test = get_dataset(test_data, PID, TEXT, None, test=True)

# 构建词汇表
TEXT.build_vocab(train, vectors=Vectors(
    name='.vector_cache/glove.6B.50d.txt', cache='.vector_cache'))

class LSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers):
        super(LSTM, self).__init__()
        self.embedding = nn.Embedding(len(TEXT.vocab), embedding_dim)
        self.embedding.weight.data.copy_(TEXT.vocab.vectors)
        self.lstm = nn.LSTM(input_size=embedding_dim, hidden_size=hidden_dim,
                            num_layers=num_layers, bidirectional=False)
        self.relu = nn.ReLU()
        self.fc = nn.Linear(hidden_dim * num_layers * 1, 5)

    def forward(self, x):
        embedding = self.relu(self.embedding(x[0]))
        packed_embedding = nn.utils.rnn.pack_padded_sequence(embedding, x[1])
        output, (hidden, cell) = self.lstm(packed_embedding)
        hidden = hidden.view(hidden.size()[1], -1)
        out = self.fc(self.relu(hidden))
        return out

def binary_acc(preds, y):
    preds = torch.argmax(preds, dim=1)
    correct = torch.eq(preds, y).float()
    return correct.sum()


lstm = LSTM(len(TEXT.vocab), 50, 64, 1)
optimizer = optim.Adam(lstm.parameters())  # 优化器
loss_fn = nn.CrossEntropyLoss()  # 使用交叉熵作为损失函数

train_iter, val_iter = data.BucketIterator.splits(
    (train, val),
    batch_sizes=(64, 64),
    device=-1,  # 使用CPU
    sort_key=lambda x: len(x.Phrase),
    sort_within_batch=True,
    repeat=False)
epochs = 20
loss_acc = []

for epoch in range(epochs):
    train_acc = 0
    train_loss = 0
    for batch in train_iter:
        preds = lstm(batch.Phrase)
        loss = loss_fn(preds, batch.Sentiment)
        train_acc += binary_acc(preds, batch.Sentiment).item()
        train_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    val_acc = 0
    val_loss = 0
    for batch in val_iter:
        preds = lstm(batch.Phrase)
        loss = loss_fn(preds, batch.Sentiment)
        val_acc += binary_acc(preds, batch.Sentiment).item()
        val_loss += loss.item()

    loss_acc.append([train_loss / len(train_iter.dataset), train_acc / len(train_iter.dataset),
                     val_loss / len(val_iter.dataset), val_acc / len(val_iter.dataset)])
    print('Epoch: {}/{} - \tLoss: {:.6f} - \tAcc: {:.6f} - \tVal_Loss: {:.6f} - \tVal_Acc: {:.6f}'.format(
        epoch, epochs, loss_acc[-1][0], loss_acc[-1][1], loss_acc[-1][2], loss_acc[-1][3]))
    # 保存checkpoint
    torch.save(lstm, 'models/epoch{}_checkpoint.pkl'.format(epoch))

test_iter = data.Iterator(test, batch_size=8, device=-1,
                          sort_key=lambda x: len(x.Phrase), sort_within_batch=True, repeat=False)
# 加载已保存模型
lstm = torch.load('models/epoch5_checkpoint.pkl')
# 创建csv文件
dataframe = pandas.DataFrame(columns=['PhraseId', 'Sentiment'])
dataframe.to_csv('datasets/sampleSubmission.csv', index=False)
# 预测
for batch in test_iter:
    preds = lstm(batch.Phrase)
    preds = torch.argmax(preds, dim=1)
    res = list(zip(batch.PhraseId.detach().numpy(), preds.detach().numpy()))
    df = pandas.DataFrame(res)
    df.to_csv('datasets/sampleSubmission.csv',
              mode='a+', header=False, index=False)
# 根据PhraseId对数据进行重排
df = pandas.read_csv('datasets/sampleSubmission.csv')
df.sort_values(['PhraseId'], ascending=True, inplace=True)
df.to_csv('datasets/sampleSubmission1.csv', index=False)

import numpy
from matplotlib import pyplot
locc_acc = numpy.array(loss_acc).T.tolist()
pyplot.plot(loss_acc[0])
pyplot.plot(loss_acc[2])
pyplot.xlabel('epoch')
pyplot.ylabel('loss')
pyplot.xticks([i for i in range(20)])
pyplot.show()
pyplot.plot(loss_acc[1])
pyplot.plot(loss_acc[3])
pyplot.xlabel('epoch')
pyplot.ylabel('acc')
pyplot.xticks([i for i in range(20)])
pyplot.show()