注:本文为学习 DataWhale 开源教程《深入浅出 Pytorch》第四章所做学习笔记,基于实战教程,实现了使用 LSTM 模型的中文微博情感分析全过程。
本文使用中文微博情感分析数据集(Pytorch_practice/weibo_senti_100k.csv at main · nowadays0421/Pytorch_practice (github.com)),基于 Pytorch 基础使用构建了简单 LSTM 模型实现情感分析。
本文导入的第三方库包括:
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
import pandas as pd
import jieba
from tqdm import tqdm
from torch.nn.utils.rnn import pack_padded_sequence
from torch.nn.utils.rnn import pad_sequence
from collections import defaultdict
from torch import optim
from torch.nn import functional as F
本地数据集以 csv 格式存在,首先通过 pandas 库将本地数据读取成 DataFrame 类型:
whole_data = pd.read_csv(data_path)
# data_path 为本地数据路径
自然语言处理需要将自然语言 token (句、词、短语皆可,自然语言处理任务的最小单元)映射为一个实数,因此定义一个词表类型,用于将自然语言文本映射为向量:
'''定义一个词表类型。'''
# 该类用于实现token到索引的映射
class Vocab:
def __init__(self, tokens = None) -> None:
# 构造函数
# tokens:全部的token列表
self.idx_to_token = list()
# 将token存成列表,索引直接查找对应的token即可
self.token_to_idx = dict()
# 将索引到token的映射关系存成字典,键为索引,值为对应的token
if tokens is not None:
# 构造时输入了token的列表
if "" not in tokens:
# 不存在标记
tokens = tokens + ""
for token in tokens:
self.idx_to_token.append(token)
self.token_to_idx[token] = len(self.idx_to_token) - 1
# 当前该token对应的索引是当下列表的最后一个
self.unk = self.token_to_idx["" ]
@classmethod
def build(cls, data, min_freq=1, reserved_tokens=None, stop_words = 'hit_stopwords.txt'):
# 构建词表
# cls:该类本身
# data: 输入的文本数据
# min_freq:列入token的最小频率
# reserved_tokens:额外的标记token
# stop_words:停用词文件路径
token_freqs = defaultdict(int)
stopwords = open(stop_words).read().split('\n')
for i in tqdm(range(data.shape[0]), desc=f"Building vocab"):
for token in jieba.lcut(data.iloc[i]["review"]):
if token in stop_words:
continue
token_freqs[token] += 1
# 统计各个token的频率
uniq_tokens = ["" ] + (reserved_tokens if reserved_tokens else [])
# 加入额外的token
uniq_tokens += [token for token, freq in token_freqs.items() \
if freq >= min_freq and token != "" ]
# 全部的token列表
return cls(uniq_tokens)
def __len__(self):
# 返回词表的大小
return len(self.idx_to_token)
def __getitem__(self, token):
# 查找输入token对应的索引,不存在则返回返回的索引
return self.token_to_idx.get(token, self.unk)
def convert_tokens_to_ids(self, tokens):
# 查找一系列输入标签对应的索引值
return [self[token] for token in tokens]
def convert_ids_to_tokens(self, ids):
# 查找一系列索引值对应的标记
return [self.idx_to_token[index] for index in ids]
接着,实现一个封装函数用于实现 token 映射与构建训练集、测试集;
'''数据集构建函数'''
def build_data(data_path:str):
'''
Args:
data_path:待读取本地数据的路径
Returns:
训练集、测试集、词表
'''
whole_data = pd.read_csv(data_path)
# 读取数据为 DataFrame 类型
vocab = Vocab.build(whole_data)
# 构建词表
train_data = [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in whole_data[whole_data["label"] == 1][:50000]["review"]]\
+[(vocab.convert_tokens_to_ids(sentence), 0) for sentence in whole_data[whole_data["label"] == 0][:50000]["review"]]
# 分别取褒贬各50000句作为训练数据,将token映射为对应的索引值
test_data = [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in whole_data[whole_data["label"] == 1][50000:]["review"]]\
+[(vocab.convert_tokens_to_ids(sentence), 0) for sentence in whole_data[whole_data["label"] == 0][50000:]["review"]]
# 其余数据作为测试数据
return train_data, test_data, vocab
使用 Pytorch 需要构建一个自定义数据集,并实现样本抽取函数:
'''声明一个 DataSet 类'''
class MyDataset(Dataset):
def __init__(self, data) -> None:
# data:使用词表映射之后的数据
self.data = data
def __len__(self):
# 返回样例的数目
return len(self.data)
def __getitem__(self, index):
return self.data[index]
'''声明一个collate_fn函数,用于对一个批次的样本进行整理'''
def collate_fn(examples):
# 从独立样本集合中构建各批次的输入输出
lengths = torch.tensor([len(ex[0]) for ex in examples])
# 获取每个序列的长度
inputs = [torch.tensor(ex[0]) for ex in examples]
# 将输入inputs定义为一个张量的列表,每一个张量为句子对应的索引值序列
targets = torch.tensor([ex[1] for ex in examples], dtype=torch.long)
# 目标targets为该批次所有样例输出结果构成的张量
inputs = pad_sequence(inputs, batch_first=True)
# 将用pad_sequence对批次类的样本进行补齐
return inputs, lengths, targets
搭建一个简单 LSTM 模型,实现建模:
'''创建一个LSTM类作为模型'''
class LSTM(nn.Module):
# 基类为nn.Module
def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class):
# 构造函数
# vocab_size:词表大小
# embedding_dim:词向量维度
# hidden_dim:隐藏层维度
# num_class:多分类个数
super(LSTM, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
# 词向量层
self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first = True)
# lstm层
self.output = nn.Linear(hidden_dim, num_class)
# 输出层,线性变换
def forward(self, inputs, lengths):
# 前向计算函数
# inputs:输入
# lengths:打包的序列长度
# print(f"输入为:{inputs.size()}")
embeds = self.embedding(inputs)
# 注意这儿是词向量层,不是词袋词向量层
# print(f"词向量层输出为:{embeds.size()}")
x_pack = pack_padded_sequence(embeds, lengths.to('cpu'), batch_first=True, enforce_sorted=False)
# LSTM需要定长序列,使用该函数将变长序列打包
# print(f"经过打包为:{x_pack.size()}")
hidden, (hn, cn) = self.lstm(x_pack)
# print(f"经过lstm计算后为:{hn.size()}")
outputs = self.output(hn[-1])
# print(f"输出层输出为:{outputs.size()}")
log_probs = F.log_softmax(outputs, dim = -1)
# print(f"输出概率值为:{probs}")
# 归一化为概率值
return log_probs
实现上述操作之后,进行训练和预测即可:
nll_loss = nn.NLLLoss()
# 负对数似然损失
optimizer = optim.Adam(model.parameters(), lr=0.001)
# Adam优化器
model.train()
for epoch in range(num_epoch):
total_loss = 0
for batch in tqdm(train_data_loader, desc=f"Training Epoch {epoch}"):
inputs, lengths, targets = [x.to(device) for x in batch]
# print(inputs.size())
log_probs = model(inputs, lengths)
loss = nll_loss(log_probs, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Loss:{total_loss:.2f}")
# 测试
acc = 0
for batch in tqdm(test_data_loader, desc=f"Testing"):
inputs, lengths, targets = [x.to(device) for x in batch]
with torch.no_grad():
output = model(inputs, lengths)
acc += (output.argmax(dim=1) == targets).sum().item()
print(f"ACC:{acc / len(test_data_loader):.2f}")
本文采用负对数似然损失,使用 Adam 优化器,测试时计算准确率。
在使用简单 LSTM 模型,使用十万条样本作为训练集的情况下,测试准确率可以达到98%:
注:全部代码参见 Github Pytorch_practice/sentiment_classify.py at main · nowadays0421/Pytorch_practice (github.com)