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

RNN实现谣言检测

    • 遇到的问题:
    • 数据处理篇
    • 模型搭建和数据提取篇

--------更新时间-------2019/06/08
人真的可以生如蚁,而美如神!
时间不多,废话少说!先处理数据!

遇到的问题:

  1. 训练时,loss总是在几个数之间,每一轮训练的精度都是一样的!
    这个问题我刚开始以为是模型的weigth和bias没有更新,导致每次训练都是固定的参数在跑,结果打印可更新的参数,发现
    pytorch实现RNN,majing论文的谣言检测_第1张图片所以,排除了这个。

数据处理篇

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

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

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

模型搭建和数据提取篇

这里还是作为重点介绍:
pytorch实现RNN,majing论文的谣言检测_第2张图片pytorch实现RNN,majing论文的谣言检测_第3张图片
这里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 = Train

        self.MO = word2vec.Word2Vec.load('./WordModel')

    def __getitem__(self, item):
        X = []
        Y = None
        if 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 +'没有向量化!')
                continue
        X = torch.tensor(X[0:30])  # 这里由于每条句子长度不一致,导致无法封装到一个batch里,所以才设置取前30
        Y = 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,Y

    def __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_layers
        self.input_size = input_size
        self.lstm = lstm
        self.hidden_size = hidden_size
        self.gpu = GPU
        if 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-3
    model = 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 = trainset
            X = 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 = valiset
            v_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散点图!
请看官笑纳:

pytorch实现RNN,majing论文的谣言检测_第4张图片pytorch实现RNN,majing论文的谣言检测_第5张图片最后祝大家生活愉快!
附上代码链接,Github地址:https://github.com/liAoI/RNN-pytorch–,不要忘了加星哦!

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

希望大家如果有更好更大的数据集,能给我留言,发我一份,在此小弟不甚感激!(感动)

你可能感兴趣的:(pytorch)