python3.6+torch1.2实现Sentiment Analysis（数据集MR）
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python3.6+torch1.2实现Sentiment Analysis（数据集MR），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12270字，纯文字阅读大概需要18分钟。
内容图文
总共是下面几个文件：
注意，最后一个是json文件，里面是电影影评数据集MR的划分出来的训练集生成的词典。是个字典文件，也可以自己再弄一个。
在训练集上训练了10个epoch，结果大概是上图这个样子
1、创建model_para.py文件，里面是模型的超参数。
import argparse
class Hpara():
parser = argparse.ArgumentParser()
############# insert paras #############
parser.add_argument('--batch_size',default = 16, type = int) # batch_size
parser.add_argument('--epochs',default = 1, type = int) # epochs
parser.add_argument('--lr',default = 3*10**(-5), type = float) # learning rate
parser.add_argument('--l2_lambda',default = 0.0, type = float) # L2_loss lambda
parser.add_argument('--seg_net_nums_layer',default = 6, type = int) # segnet Rnn Layers
parser.add_argument('--seg_net_dropout_rate',default = 0.2, type = float) # segnet dropout rate
parser.add_argument('--seg_net_hidden_size',default = 64, type = int) # segnet hidden size
parser.add_argument('--seg_net_n_best',default = 12, type = int) # sample nums
parser.add_argument('--seg_net_beam_size',default = 8, type = int) # beam size
parser.add_argument('--seg_net_rnntype',default = 'GRU', type = str) # segnet Rnn Type
parser.add_argument('--is_bi_rnn',default = True, type = bool) # segnet bi_Rnn
parser.add_argument('--unfreezing_bert_nums',default = 12, type = int)
parser.add_argument('--is_training_bert',default = True, type = bool)
parser.add_argument('--is_load_best_model', default = False ,type = bool)
## MLP model paras
parser.add_argument('--MLP_hidden_nums_layer',default = 1, type = int)
parser.add_argument('--Bert_drop_out',default = 0.1, type = float)
## SA model paras
parser.add_argument('--SA_hidden_dim',default = 256, type = int)
parser.add_argument('--SA_is_bi',default = True, type = bool)
parser.add_argument('--SA_dropout_rate',default = 0.4, type = float)
parser.add_argument('--SA_word_dim',default = 300, type = int)
parser.add_argument('--SA_vocab_size',default = 16783, type = int)
parser.add_argument('--SA_layer_nums',default = 2, type = int)
parser.add_argument('--SA_Rnn_type',default = 'LSTM', type = str)
parser.add_argument('--pretrained_bert_path',default = '/bert-base-uncased', type = str)
parser.add_argument('--bert_out_size',default = 768, type = int)
parser.add_argument('--bert_vocab_path',default = /bert-base-uncased/vocab.txt', type = str)
parser.add_argument('--saved_model_path',default = './best_model', type = str)
parser.add_argument('--final_model_path',default = './final_epoch_saved_model', type = str)
## SegNet model paras
parser.add_argument('--pretrained_segnet_model',default = './segnet_model/trained_model.torchsave', type = str)
parser.add_argument('--seg_net_vocab',default = './segnet_model/all_vocabulary.pickle', type = str)
parser.add_argument('--seg_net_vocab_size',default = 16703, type = int)
parser.add_argument('--seg_net_embed_size',default = 300, type = int)
parser.add_argument('--seg_net_use_cuda',default = False, type = bool)
parser.add_argument('--seg_net_finetuning',default = False, type = bool)
parser.add_argument('--seg_net_isbanor',default = True, type = bool)
## Other paras
parser.add_argument('--emotion_label_nums',default = 2, type = int)
parser.add_argument('--train_csv',default = r'./data/train_1.csv', type = str)
parser.add_argument('--test_csv',default = r'./data/test_1.csv', type = str)
parser.add_argument('--val_csv',default = r'./data/val_1.csv', type = str)
这个里面的参数是我在别的一个项目里面直接复制过来的，很多参数没有修改，实际使用到的参数很少。可以在代码里面自己看一下
2、创建数据处理文件data_utils.py
该文件主要用来加载数据集，并且分成batch输入到模型里面，还有最重要的对文本按照长度进行排序，这样做的目的是LSTM或者别的RNN在计算的时候不考虑padding。
import numpy as np
import json
import pandas as pd
def del_none(text): # delete ‘’ 删除使用空格切分之后句子里面的长度为0的字符串
new_text = []
for t in text:
ws = t.split(' ')
ws = [w for w in ws if w != '']
new_text.append(' '.join(ws))
return new_text
def read_csv(para):# read Moive Review DataSet
train_data = pd.read_csv(para.train_csv, delimiter=',')
test_data = pd.read_csv(para.test_csv, delimiter=',')
val_data = pd.read_csv(para.val_csv, delimiter=',')
train_text = list(train_data['INPUT'])
train_label = list(train_data['OUTPUT'])
test_text = list(test_data['INPUT'])
test_label = list(test_data['OUTPUT'])
val_text = list(val_data['INPUT'])
val_label = list(val_data['OUTPUT'])
train_text = del_none(train_text)
test_text = del_none(test_text)
val_text = del_none(val_text)
train_label = np.array(train_label, dtype=np.int32)
test_label = np.array(test_label, dtype=np.int32)
val_label = np.array(val_label, dtype=np.int32)
return train_text, test_text, val_text, train_label, test_label, val_label
def create_dict(train_text):
for t in train_text:
ws = t.split(' ')
aw.extend(ws)
vocab = list(set(aw))
vd = dict(zip(vocab, range(2,len(vocab)+2)))
vd['UNKNOWN'] = 1
vd['PADDING'] = 0
with open('vd.json', 'w', encoding='utf-8') as f:
json.dump(vd, f)
def get_vd(path):
f = open(path,'r', encoding='utf-8')
vd = json.load(f)
return vd
def text2id(text, vd):
bs = len(text)
lens = [len(t.split(' ')) for t in text]
ml = max(lens)
text_id = np.zeros(shape = (bs, ml), dtype=np.int32)
words = list(vd.keys())
for i in range(bs):
ws = text[i].split(' ')
for j in range(lens[i]):
if ws[j] in words:
text_id[i,j] = vd[ws[j]]
else:
text_id[i, j] = vd['UNKNOWN']
return text_id, lens
def sort_data_by_length(textid, label, lengths):
lengths = np.array(lengths, dtype=np.int32)
idx = np.argsort(lengths)
idx = idx[::-1]
lengths = lengths[idx]
sc_id = textid[idx]
label = label[idx]
return sc_id, label, lengths
def batch_iter_str(text, label , batch_size = 16):
path = 'vd.json'
vd = get_vd(path)
data_nums = len(text)
num_batch = (data_nums + batch_size - 1) // batch_size
indices = np.random.permutation(np.arange(data_nums))
text = [text[i] for i in indices]
label = label[indices]
for i in range(num_batch):
start_offset = i * batch_size
end_offset = min(start_offset + batch_size, data_nums)
bt_text = text[start_offset:end_offset]
bt_label = label[start_offset:end_offset]
text_id, lens = text2id(bt_text, vd)
sc_id, bt_label, lengths = sort_data_by_length(text_id, bt_label, lens)
yield i, num_batch, sc_id, bt_label, lengths
3、创建Model.py文件
import torch.nn as nn
import torch
device = torch.device("cuda:4" if torch.cuda.is_available() else "cpu")
class sa_model(nn.Module):
def __init__(self, para):
super(sa_model, self).__init__()
self.para = para
if para.SA_Rnn_type == 'LSTM':
self.RNN = nn.LSTM(input_size = para.SA_word_dim,
hidden_size = para.SA_hidden_dim,
num_layers = para.SA_layer_nums,
batch_first = True,
dropout = para.SA_dropout_rate,
bidirectional = para.SA_is_bi)
elif para.SA_Rnn_type == 'GRU':
self.RNN = nn.GRU(input_size = para.SA_word_dim,
hidden_size = para.SA_hidden_dim,
num_layers = para.SA_layer_nums,
batch_first = True,
dropout = para.SA_dropout_rate,
bidirectional = para.SA_is_bi)
elif para.SA_Rnn_type == 'RNN':
self.RNN = nn.RNN(input_size = para.SA_word_dim,
hidden_size = para.SA_hidden_dim,
num_layers = para.SA_layer_nums,
batch_first = True,
dropout = para.SA_dropout_rate,
bidirectional = para.SA_is_bi)
self.nnEm = nn.Embedding(para.SA_vocab_size, para.SA_word_dim, padding_idx = 0).to(device)
self.criterion = nn.CrossEntropyLoss()
self.linear = nn.Linear(para.SA_hidden_dim*2, para.emotion_label_nums)
def forward(self, x, x_len, label):
x = self.nnEm(x)
packed_embeds = nn.utils.rnn.pack_padded_sequence(x, x_len, batch_first=True)
out, hs = self.RNN(packed_embeds)
out, _ = nn.utils.rnn.pad_packed_sequence(out,
batch_first=True)
h1 = hs[0][0]
h2 = hs[0][1]
h = torch.cat([h1, h2], dim = 1)
logits = self.linear(h)
loss = self.criterion(logits, label)
pred = torch.argmax(torch.nn.functional.softmax(logits, dim = 1), dim = 1)
return loss, pred
4、创建train.py文件
from Model import sa_model
from data_utils import batch_iter_str, read_csv
import torch
from model_para import Hpara
import torch.optim as optim
import matplotlib.pyplot as plt
from tqdm import tqdm
import os
from sklearn.metrics import accuracy_score
device = torch.device("cuda:4" if torch.cuda.is_available() else "cpu")
print(device)
def train(text, label, model, epoch):
optimizer = optim.RMSprop(filter(lambda p: p.requires_grad, model.parameters()), lr = para.lr * (0.95)**epoch)
pred_label = []
true_label = []
all_loss = []
model.train()
db = batch_iter_str(text, label)
for i, num_batch, sc_id, label, lengths in db:
sc_id = torch.tensor(sc_id).long().to(device)
label = torch.tensor(label).long().to(device)
lens = torch.tensor(lengths).long().to(device)
model.zero_grad()
loss ,pred = model(sc_id, lens, label)
all_loss.append(loss)
pred_label.append(pred)
true_label.append(label)
loss.backward()
optimizer.step()
if (i+1)%10 == 0:
print('%d step loss is : %f'%(i+1, loss.item()))
print('%d acc is : %f'%(i+1, accuracy_score(label.data.cpu().numpy(), pred.data.cpu().numpy())))
mean_loss = sum(all_loss) / num_batch
pred_label = torch.cat(pred_label, dim = 0)
true_label = torch.cat(true_label, dim = 0)
mean_acc = accuracy_score(true_label, pred_label)
return mean_loss, mean_acc
def test(saved_acc, text, label, model, mode = 'validation'):
pred_label = []
true_label = []
all_loss = []
model.eval()
db = batch_iter_str(text, label)
for i, num_batch, sc_id, label, lengths in db:
sc_id = torch.tensor(sc_id).long().to(device)
label = torch.tensor(label).long().to(device)
lens = torch.tensor(lengths).long().to(device)
model.zero_grad()
loss ,pred = model(sc_id, lens, label)
all_loss.append(loss)
pred_label.append(pred)
true_label.append(label)
mean_loss = sum(all_loss) / num_batch
pred_label = torch.cat(pred_label, dim = 0)
true_label = torch.cat(true_label, dim = 0)
mean_acc = accuracy_score(true_label, pred_label)
if mode == 'validation':# save the best model when the mode is 'validation'
if mean_acc >= saved_acc:
torch.save(model, os.path.join(para.saved_model_path,'My_model_pth'))
saved_acc = mean_acc
## TODO: the next step is to save the model every epoch
torch.save(model, os.path.join(para.final_model_path,'My_model_pth'))
return mean_loss, mean_acc, saved_acc
def load_model(para, model, best_model = True):
if best_model:
model_path = para.saved_model_path
else:
model_path = para.final_model_path
if os.path.exists(os.path.join(model_path, 'My_model_pth')):
print('model path is : ', model_path)
model = torch.load(os.path.join(model_path, 'My_model_pth'))
print('load pre-train')
else:
model = model
return model
if __name__ == '__main__':
saved_acc = 0.0
hp=Hpara()
parser = hp.parser
para = parser.parse_args()
train_text, test_text, val_text, train_label, test_label, val_label = read_csv(para)
model = sa_model(para)
model = model.to(device)
if para.is_load_best_model:
print('load the best model...')
_, _, saved_acc = test(saved_acc, val_text, val_label, model, mode = 'get_saved_acc')
model = load_model(para, model)
else:
print('load the final epoch model...')
_, _, saved_acc = test(saved_acc, val_text, val_label, model, mode = 'get_saved_acc')
model = load_model(para, model, best_model = False)
print('saved accuracy is :', saved_acc)
train_loss = []
train_acc = []
val_loss = []
val_acc = []
test_loss = []
test_acc = []
for i in range(para.epochs):
########### train ###########
train_mean_loss_i, train_mean_acc_i = train(train_text, train_label, model, i)
train_loss.append(train_mean_loss_i)
train_acc.append(train_mean_acc_i)
########## val #############
val_loss_i, val_acc_i, saved_acc = test(saved_acc, val_text, val_label, model, )
print('%d epoch val acc is', val_acc_i)
val_loss.append(val_loss_i)
val_acc.append(val_acc_i)
########## test ###########
test_loss_i, test_acc_i, saved_acc = test(saved_acc, test_text, test_label, model, mode = 'test')
print('%d epoch test acc is :', test_acc_i)
test_loss.append(test_loss_i)
test_acc.append(test_acc_i)
plt.figure(2)
plt.subplot(231)
plt.plot(train_loss)
plt.xlabel('epochs')
plt.ylabel('emotion_train_loss')
plt.subplot(232)
plt.plot(test_loss)
plt.xlabel('epochs')
plt.ylabel('emotion_test_loss')
plt.subplot(233)
plt.plot(val_loss)
plt.xlabel('epochs')
plt.ylabel('emotion_val_loss')
plt.subplot(234)
plt.plot(train_acc)
plt.xlabel('epochs')
plt.ylabel('emotion_train_acc')
plt.subplot(235)
plt.plot(test_acc)
plt.xlabel('epochs')
plt.ylabel('emotion_test_acc')
plt.subplot(236)
plt.plot(val_acc)
plt.xlabel('epochs')
plt.ylabel('emotion_val_acc')
plt.show()
5、完整的代码
链接：https://pan.baidu.com/s/1nWMThnz9eK8zVggQJ7Umag
提取码：0rwq
复制这段内容后打开百度网盘手机App，操作更方便哦
内容总结
以上是互联网集市为您收集整理的python3.6+torch1.2实现Sentiment Analysis（数据集MR）全部内容，希望文章能够帮你解决python3.6+torch1.2实现Sentiment Analysis（数据集MR）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】