pytorch实现RNN，majing论文的谣言检测_majing数据集

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

遇到的问题：

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

数据处理篇

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

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

这就算处理好了数据。接下来，开始用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 = 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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

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

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

我们通过迭代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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

这里写的很臃肿，主要是为了既能在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)
1
2

通过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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

这里如果将代码一句一句解释的话就有点罗嗦了，我主要说一下怎样算在验证数据集上的精度。
将一轮训练后模型在验证数据集上跑一遍。具体，验证数据集也是通过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))
1

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

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

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

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