pytorch实现RNN，majing论文的谣言检测

遇到的问题：

1. 训练时，loss总是在几个数之间，每一轮训练的精度都是一样的！
   这个问题我刚开始以为是模型的weigth和bias没有更新，导致每次训练都是固定的参数在跑，结果打印可更新的参数，发现
   所以，排除了这个。

数据处理篇

拿到majing的微博数据，发现每一个微博原文都是json文件，里面存放的是原始微博和一些用户的评论以及转发信息。
首先，去除重复的微博文本。这个很简单，就是用网上的聚类分析那些文本是一样的，这里我不多说，因为这个工作已经被同学做了。
然后，开始处理剩下的不重复文本，我处理的办法很简单：

		- 提取原始微博和下面的评论，也就是一个json文件中的所有origrial-text。- 按原始文本的文件命名，里面存放用jieba分好词的内容- 将所有的微博加评论都写到一个txt文件中，用word2vec训练出词向量。

这就算处理好了数据。接下来，开始用pytorch写model，然后取数据进行训练

模型搭建和数据提取篇

这里还是作为重点介绍：

这里data目录下，主要放的是已经分号词的微博文本的json格式。里面只有分好词的文本和标签。
wordmodel是之前用word2vec训练后，保存的词向量。
接下来写pytorch给我们定义好的dataload：

#将数据分成四份，一份测试，其余作训练
class ShipDataset(data.Dataset):def __init__(self,vali = 1,Train = True,dir='./data'):super(ShipDataset, self).__init__()self.train = []self.vaild = []#获取数据清单flist = []for root, dirs, files in os.walk(dir):for file in files:if os.path.splitext(file)[1] == '.json':flist.append(os.path.join(root, file))flist = [flist[i:i + len(flist)//5] for i in range(0, len(flist), len(flist)//5)]for i in range(len(flist)):if i == vali:self.vaild = flist[i]else:self.train +=flist[i]self.ModeTrain = Trainself.MO = word2vec.Word2Vec.load('./WordModel')def __getitem__(self, item):X = []Y = Noneif self.ModeTrain:filename = self.train[item]else:filename = self.vaild[item]with open(filename, 'r', encoding='utf-8') as f:fjson = json.load(f)for i in fjson['text']:try:X.append(self.MO[i])except (KeyError):# logger.info(i +'没有向量化！')continueX = torch.tensor(X[0:30])  # 这里由于每条句子长度不一致，导致无法封装到一个batch里，所以才设置取前30Y = int(fjson['label'])# Y = torch.tensor(int(fjson['label'])).float()if Y == 0 :    #非谣言Y = torch.tensor([0.0,1.0])else:Y = torch.tensor([1.0,0.0])return X,Ydef __len__(self):#返回数据的数量if self.ModeTrain:return len(self.train)else:return len(self.vaild)

这样将数据可以打包成batchSize，十分方便。后面训练的时候直接调用这个类，如下：

train_data = ShipDataset()
train_loader = data.DataLoader(train_data, batch_size=4, num_workers=0, shuffle=False)

我们通过迭代train_loader来取数据，放到模型里训练了。

接下来就是介绍模型定义，pytorch定义模型十分方便和直观，也很灵活。如果要做对比实验，使用它相比tensorflow要好用的多，为啥呢？因为pytorch使用动态图，在一个类里面可以定义很多个，训练的时候直接拿出来用，不像tensorflow，要先把所有模型都定义完，然后session.run()，这样违背我们常规编程思维。pytorch如果说像python语言的话，那么tensorflow就像C++之类的，需要编译、链接，最后run，一旦一个地方出错，即使这个地方前面的代码没毛病，也会退出，不执行。
废话不多说，先模型定义：

class RNNModel(nn.Module):def __init__(self,input_size,hidden_size,n_layers,lstm,GPU):super(RNNModel, self).__init__()self.n_layers = n_layersself.input_size = input_sizeself.lstm = lstmself.hidden_size = hidden_sizeself.gpu = GPUif self.gpu == True:self.rnn = nn.LSTM(input_size, hidden_size, n_layers, batch_first=True ).cuda()self.gru = nn.GRU(input_size, hidden_size, n_layers, batch_first=True).cuda()# self.linear = nn.Linear(self.hidden_size,2)  #二分类，最后结果[0,1] [1,0]self.layer = nn.Sequential(nn.Linear(self.hidden_size, 2), nn.Sigmoid()).cuda()else:self.rnn = nn.LSTM(input_size, hidden_size, n_layers, batch_first=True)self.gru = nn.GRU(input_size, hidden_size, n_layers, batch_first=True)self.layer = nn.Sequential(nn.Linear(self.hidden_size, 2), nn.Sigmoid())def forward(self,input,state=None):batch, _, _ = input.size()if self.gpu == True:if self.lstm == True:if state is None:h = torch.randn(self.n_layers, batch, self.hidden_size).cuda().float()c = torch.randn(self.n_layers, batch, self.hidden_size).cuda().float()else:h, c = state# output [batchsize,time,hidden_size]output, state = self.rnn(input, (h, c))else:if state is None:state = torch.randn(self.n_layers, batch, self.hidden_size).cuda().float()output, state = self.gru(input, state)else:if self.lstm == True:if state is None:h = torch.randn(self.n_layers, batch, self.hidden_size).float()c = torch.randn(self.n_layers, batch, self.hidden_size).float()else:h, c = state# output [batchsize,time,hidden_size]output, state = self.rnn(input, (h, c))else:if state is None:state = torch.randn(self.n_layers, batch, self.hidden_size).float()output, state = self.gru(input, state)#最后输出结果output = self.layer(output[:, -1, :])return output,state

这里写的很臃肿，主要是为了既能在CPU上跑，又能运行在GPU上。好的机器当然要用好的资源嘛！
上面类定义了GRU和lstm，可以通过参数选择要使用的训练模型：

self.rnn = nn.LSTM(input_size, hidden_size, n_layers, batch_first=True)
self.gru = nn.GRU(input_size, hidden_size, n_layers, batch_first=True)

通过self.lstm 这个来选择，是不是很方便。tensorflow有这样灵活吗？
接下来就是RUN函数了，这个就是训练了！
话不多说，献上代码，这里只看在GPU上跑的代码
loss损失函数采用nn.BCELoss()。这个是对二分类的交叉损失函数！（这个我没看具体源码和公式，不知道pytorch是怎么封装的，所以有错误还请批评指正！）

def RunGPU(opt):#将模型迁移到GPU上lr = 1e-3model = RNNModel(opt.inputsize, opt.hidden_size, opt.layers,lstm=True,GPU=True).cuda()optimizer = torch.optim.Adam(model.parameters(), lr=lr)criterion = nn.BCELoss().cuda()# 查看可更新的参数# for name, param in model.named_parameters():#     if param.requires_grad:#         print(name)# return#将数据迁移到GPU`train_data = ShipDataset(vali=2)train_loader = data.DataLoader(train_data, batch_size=6, num_workers=2, shuffle=False)valid_data = ShipDataset(vali=2,Train=False)valid_loader = data.DataLoader(valid_data, batch_size=8, num_workers=2, shuffle=False)for epoch in range(opt.epochs):# lr = adjust_learning_rate(lr, epoch)for i, trainset in enumerate(train_loader):X, Y = trainsetX = torch.tensor(X).cuda()Y = torch.tensor(Y).cuda()out_y, _ = model(X)# logger.info(Y)# logger.info(out_y)loss = criterion(out_y, Y)optimizer.zero_grad()loss.backward()optimizer.step()# for param in model.named_parameters():#     logger.info(param)if i % 100 == 0:print('batch_loss: {0},学习率为{1}'.format(loss, lr))out = torch.tensor([[0.0,0.0]]).cuda()y = torch.tensor([[0.0,0.0]]).cuda()for valiset in valid_loader:v_X,v_Y = valisetv_X = torch.tensor(v_X).cuda()v_Y = torch.tensor(v_Y).cuda()out_y, _ = model(v_X)# logger.info(out_y)# logger.info(out)out = torch.cat((out,out_y),0)y = torch.cat((y,v_Y),0)# logger.info(out)# logger.info(y)correct_pred = torch.eq(torch.argmax(out, 1), torch.argmax(y, 1))acc = correct_pred.sum().item()/ y.size(0)print('第 {0} 轮训练精度为 {1}'.format(epoch + 1, acc))viz.scatter(X=np.array([[epoch + 1, loss.item()]]), name='loss', win=loss_win, update='append')viz.scatter(X=np.array([[epoch + 1, acc]]), name='acc', win=acc_win, update='append')if acc > 0.90:torch.save({'epoch': epoch + 1,# 'arch': args.arch,'state_dict': model.state_dict(),'loss': loss,}, 'checkpoint{0}.tar'.format(epoch + 1))

这里如果将代码一句一句解释的话就有点罗嗦了，我主要说一下怎样算在验证数据集上的精度。
将一轮训练后模型在验证数据集上跑一遍。具体，验证数据集也是通过dataload取的，所以是一个batchsize一个batchsize的丢到模型里面去跑，每一个batch得到一个out_y,每一个batch也有自己的标签label,然后用torch.cat()函数将这些out_y连接起来，同理label也是一样连接起来。对于一个样本，out_y会类似于[0.23，0.95],由于0.95>0.23，它可以近视认为模型把它归为第二类，也就是非谣言。Y就很直观可以取出来。两者如果最大值所在的位置是一样的，说明模型预测成功，否则，错误！

 correct_pred = torch.eq(torch.argmax(out, 1), torch.argmax(y, 1))

下面是用visdom得到的loss和acc散点图！
请看官笑纳：

最后祝大家生活愉快！
附上代码链接，Github地址：https://github.com/liAoI/RNN-pytorch–，不要忘了加星哦！

附上数据集（百度云）：
链接：https://pan.baidu.com/s/1JEpQmEmO4fVd3SrLbFYyrg
提取码：yjn4

希望大家如果有更好更大的数据集，能给我留言，发我一份，在此小弟不甚感激！（感动）