当前位置:   article > 正文

文本分类之DPCNN的原理(Pytorch实现)_dpcnn哪一年提出的

dpcnn哪一年提出的

1.简介

ACL2017 年中,腾讯 AI-lab 提出了Deep Pyramid Convolutional Neural Networks for Text Categorization(DPCNN)。

论文中提出了一种基于 word-level 级别的网络-DPCNN,由于 TextCNN 不能通过卷积获得文本的长距离依赖关系,而论文中 DPCNN 通过不断加深网络,可以抽取长距离的文本依赖关系。

实验证明在不增加太多计算成本的情况下,增加网络深度就可以获得最佳的准确率。‍

2.DPCNN 结构

究竟是多么牛逼的网络呢?我们下面来窥探一下模型的芳容。

3.DPCNN 结构细节

模型是如何通过加深网络来捕捉文本的长距离依赖关系的呢?下面我们来一一道来。为了更加简单的解释 DPCNN,这里我先不解释是什么是 Region embedding,我们先把它当作 word embedding。

等长卷积

首先交代一下卷积的的一个基本概念。一般常用的卷积有以下三类:

假设输入的序列长度为n,卷积核大小为m,步长(stride)为s,输入序列两端各填补p个零(zero padding),那么该卷积层的输出序列为(n-m+2p)/s+1。

(1) 窄卷积(narrow convolution):步长s=1,两端不补零,即p=0,卷积后输出长度为n-m+1。

(2) 宽卷积(wide onvolution) :步长s=1,两端补零p=m-1,卷积后输出长度 n+m-1。

(3) 等长卷积(equal-width convolution):步长s=1,两端补零p=(m-1)/2,卷积后输出长度为n。如下图所示,左右两端同时补零p=1,s=3。

池化

那么DPCNN是如何捕捉长距离依赖的呢?这里我直接引用文章的小标题——Downsampling with the number of feature maps fixed。

作者选择了适当的两层等长卷积来提高词位 embedding 的表示的丰富性。然后接下来就开始 Downsampling (池化)。

再每一个卷积块(两层的等长卷积)后,使用一个 size=3 和 stride=2 进行 maxpooling 进行池化。序列的长度就被压缩成了原来的一半。其能够感知到的文本片段就比之前长了一倍

例如之前是只能感知3个词位长度的信息,经过1/2池化层后就能感知6个词位长度的信息啦,这时把 1/2 池化层和 size=3 的卷积层组合起来如图所示。

固定 feature maps(filters) 的数量

为什么要固定feature maps的数量呢?许多模型每当执行池化操作时,增加feature maps的数量,导致总计算复杂度是深度的函数。与此相反,作者对 feature map 的数量进行了修正,他们实验发现增加 feature map 的数量只会大大增加计算时间,而没有提高精度。

另外,夕小瑶小姐姐在知乎也详细的解释了为什么要固定feature maps的数量。有兴趣的可以去知乎搜一搜,讲的非常透彻。

固定了 feature map 的数量,每当使用一个size=3和stride=2进行maxpooling进行池化时,每个卷积层的计算时间减半(数据大小减半),从而形成一个金字塔。

这就是论文题目所谓的Pyramid

好啦,看似问题都解决了,目标成功达成。剩下的我们就只需要重复的进行等长卷积+等长卷积+使用一个 size=3 和 stride=2 进行 maxpooling 进行池化就可以啦,DPCNN就可以捕捉文本的长距离依赖啦!

Shortcut connections with pre-activation

但是!如果问题真的这么简单的话,深度学习就一下子少了超级多的难点了。

(1) 初始化CNN的时,往往各层权重都初始化为很小的值,这导致了最开始的网络中,后续几乎每层的输入都是接近0,这时的网络输出没有意义;

(2) 小权重阻碍了梯度的传播,使得网络的初始训练阶段往往要迭代好久才能启动;

(3)就算网络启动完成,由于深度网络中仿射矩阵(每两层间的连接边)近似连乘,训练过程中网络也非常容易发生梯度爆炸或弥散问题。

当然,上述这几点问题本质就是梯度弥散问题。那么如何解决深度 CNN 网络的梯度弥散问题呢?当然是膜一下何恺明大神,然后把 ResNet 的精华拿来用啦! ResNet 中提出的shortcut-connection/ skip-connection/ residual-connection(残差连接)就是一种非常简单、合理、有效的解决方案。

类似地,为了使深度网络的训练成为可能,作者为了恒等映射,所以使用加法进行shortcut connections,即z+f(z),其中 f 用的是两层的等长卷积。这样就可以极大的缓解了梯度消失问题。

另外,作者也使用了pre-activation,这个最初在何凯明的 “Identity Mappings in Deep Residual Networks 上提及,有兴趣的大家可以看看这个的原理。

直观上,这种“线性”简化了深度网络的训练,类似于 LSTM 中 constant error carousels 的作用。而且实验证明 pre-activation 优于 post-activation。

整体来说,巧妙的结构设计,使得这个模型不需要为了维度匹配问题而担忧。

Region embedding

同时 DPCNN 的底层貌似保持了跟 TextCNN 一样的结构,这里作者将 TextCNN 的包含多尺寸卷积滤波器的卷积层的卷积结果称之为 Region embedding,意思就是对一个文本区域/片段(比如3gram)进行一组卷积操作后生成的embedding。

另外,作者为了进一步提高性能,还使用了tv-embedding (two-views embedding)进一步提高 DPCNN 的 accuracy

上述介绍了 DPCNN 的整体架构,可见 DPCNN 的架构之精美。本文是在原始论文以及知乎上的一篇文章的基础上进行整理。

 4.用 Pytorch实现 DPCNN 网络

数据集在data文件夹下

load_data.py

  1. # -*- coding: utf-8 -*-
  2. import torch
  3. import jieba
  4. from torchtext.legacy import data
  5. device = "cuda" if torch.cuda.is_available() else 'cpu'
  6. #make sure the longest sentence in the bucket is no shorter than the biggest filter size.
  7. def tokenizer(text):
  8. token = [tok for tok in jieba.cut(text)]
  9. if len(token) < 3:
  10. for i in range(0, 3 - len(token)):
  11. token.append('<pad>')
  12. return token
  13. TEXT = data.Field(sequential=True, tokenize=tokenizer)
  14. LABEL = data.Field(sequential=False, use_vocab=False)
  15. train, val = data.TabularDataset.splits(
  16. path='../data/',
  17. train='train.tsv',
  18. validation='dev.tsv',
  19. format='tsv',
  20. skip_header=True,
  21. fields=[('', None), ('label', LABEL), ('text', TEXT)])
  22. TEXT.build_vocab(train, min_freq=5)
  23. id2vocab = TEXT.vocab.itos
  24. #print(TEXT.vocab.stoi)
  25. #print(TEXT.vocab.itos)
  26. train_iter, val_iter = data.BucketIterator.splits(
  27. (train, val),
  28. sort_key=lambda x: len(x.text),
  29. batch_sizes=(256, 128),
  30. device=device)

model.py

  1. # -*- coding: utf-8 -*-
  2. import torch.nn as nn
  3. from torch.nn import functional as F
  4. class DPCNN(nn.Module):
  5. def __init__(self, trial, vocab_size, class_num):
  6. super(DPCNN, self).__init__()
  7. ci = 1 # input chanel size
  8. kernel_num = 250 # output chanel size
  9. embed_dim = trial.suggest_int("n_embedding", 200, 300, 50)
  10. self.embed = nn.Embedding(vocab_size, embed_dim, padding_idx=1)
  11. self.conv_region = nn.Conv2d(ci, kernel_num, (3, embed_dim), stride=1)
  12. self.conv = nn.Conv2d(kernel_num, kernel_num, (3, 1), stride=1)
  13. self.max_pool = nn.MaxPool2d(kernel_size=(3, 1), stride=2)
  14. self.max_pool_2 = nn.MaxPool2d(kernel_size=(2, 1))
  15. self.padding = nn.ZeroPad2d((0, 0, 1, 1)) # top bottom
  16. self.relu = nn.ReLU()
  17. self.fc = nn.Linear(kernel_num, class_num)
  18. def forward(self, x):
  19. x = self.embed(x) # x: (batch, seq_len, embed_dim)
  20. x = x.unsqueeze(1) # x: (batch, 1, seq_len, embed_dim)
  21. m = self.conv_region(x) # [batch_size, 250, seq_len-3+1, 1]
  22. x = self.padding(m) # [batch_size, 250, seq_len, 1]
  23. x = self.relu(x) # [batch_size, 250, seq_len, 1]
  24. x = self.conv(x) # [batch_size, 250, seq_len-3+1, 1]
  25. x = self.padding(x) # [batch_size, 250, seq_len, 1]
  26. x = self.relu(x) # [batch_size, 250, seq_len, 1]
  27. x = self.conv(x) # [batch_size, 250, seq_len-3+1, 1]
  28. x = x+m
  29. while x.size()[2] > 2:
  30. x = self._block(x)
  31. if x.size()[2] == 2:
  32. x = self.max_pool_2(x) # [batch_size, 250, 1, 1]
  33. x = x.squeeze() # [batch_size, 250]
  34. logit = F.log_softmax(self.fc(x), dim=1)
  35. return logit
  36. def _block(self, x): # for example: [batch_size, 250, 4, 1]
  37. px = self.max_pool(x) # [batch_size, 250, 1, 1]
  38. x = self.padding(px) # [batch_size, 250, 3, 1]
  39. x = F.relu(x)
  40. x = self.conv(x) # [batch_size, 250, 1, 1]
  41. x = self.padding(x)
  42. x = F.relu(x)
  43. x = self.conv(x)
  44. # Short Cut
  45. x = x + px
  46. return

train_eval.py

  1. # -*- coding: utf-8 -*-
  2. import torch
  3. import torch.nn as nn
  4. import torch.optim as optim
  5. import numpy as np
  6. import optuna
  7. from sklearn import metrics
  8. from optuna.trial import TrialState
  9. from model import DPCNN
  10. from load_data import train_iter, val_iter, id2vocab
  11. EPOCHS = 10
  12. CLS = 2
  13. device = "cuda" if torch.cuda.is_available() else 'cpu'
  14. def objective(trial):
  15. model = DPCNN(trial, len(id2vocab), CLS)
  16. model.to(device)
  17. optimizer_name = trial.suggest_categorical("optimizer", ["Adam", "RMSprop", "SGD"])
  18. lr = trial.suggest_float("lr", 1e-5, 1e-1, log=True)
  19. optimizer = getattr(optim, optimizer_name)(model.parameters(), lr=lr)
  20. criterion = nn.NLLLoss()
  21. for epoch in range(EPOCHS):
  22. model.train()
  23. epoch_loss= []
  24. for batch in train_iter:
  25. text_idx_batch, label_idx_batch = batch.text.t_().to(device), batch.label.to(device)
  26. model.zero_grad()
  27. out = model(text_idx_batch)
  28. loss = criterion(out, label_idx_batch)
  29. loss.backward()
  30. epoch_loss.append(loss.item())
  31. optimizer.step()
  32. #print(f'Epoch[{epoch}] - Loss:{sum(epoch_loss)/len(epoch_loss)}')
  33. model.eval()
  34. predict_all = np.array([], dtype=int)
  35. labels_all = np.array([], dtype=int)
  36. with torch.no_grad():
  37. for batch in val_iter:
  38. text_idx_batch, label_idx_batch = batch.text.t_().to(device), batch.label
  39. pred = model(text_idx_batch)
  40. pred = torch.max(pred.data, 1)[1].cpu().numpy()
  41. predict_all = np.append(predict_all, pred)
  42. truth = label_idx_batch.cpu().numpy()
  43. labels_all = np.append(labels_all, truth)
  44. acc = metrics.accuracy_score(labels_all, predict_all)
  45. trial.report(acc, epoch)
  46. if trial.should_prune():
  47. raise optuna.exceptions.TrialPruned()
  48. return acc
  49. if __name__ == '__main__':
  50. study = optuna.create_study(direction="maximize")
  51. study.optimize(objective, n_trials=8)
  52. pruned_trials = study.get_trials(deepcopy=False, states=[TrialState.PRUNED])
  53. complete_trials = study.get_trials(deepcopy=False, states=[TrialState.COMPLETE])
  54. print("Study statistics: ")
  55. print(" Number of finished trials: ", len(study.trials))
  56. print(" Number of pruned trials: ", len(pruned_trials))
  57. print(" Number of complete trials: ", len(complete_trials))
  58. print("Best trial:")
  59. trial = study.best_trial
  60. print(" Value: ", trial.value)
  61. print(" Params: ")
  62. for key, value in trial.params.items():
  63. print(" {}: {}".format(key, value))

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/盐析白兔/article/detail/849045
推荐阅读
相关标签
  

闽ICP备14008679号