文本分类之DPCNN的原理(Pytorch实现)
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 网络
load_data.py
# -*- coding: utf-8 -*-
import torch
import jieba
from torchtext.legacy import data
device = "cuda" if torch.cuda.is_available() else 'cpu'
#make sure the longest sentence in the bucket is no shorter than the biggest filter size.
def tokenizer(text):
token = [tok for tok in jieba.cut(text)]
if len(token) < 3:
for i in range(0, 3 - len(token)):
token.append('<pad>')
return token
TEXT = data.Field(sequential=True, tokenize=tokenizer)
LABEL = data.Field(sequential=False, use_vocab=False)
train, val = data.TabularDataset.splits(
path='../data/',
train='train.tsv',
validation='dev.tsv',
format='tsv',
skip_header=True,
fields=[('', None), ('label', LABEL), ('text', TEXT)])
TEXT.build_vocab(train, min_freq=5)
id2vocab = TEXT.vocab.itos
#print(TEXT.vocab.stoi)
#print(TEXT.vocab.itos)
train_iter, val_iter = data.BucketIterator.splits(
(train, val),
sort_key=lambda x: len(x.text),
batch_sizes=(256, 128),
device=device)
model.py
# -*- coding: utf-8 -*-
import torch.nn as nn
from torch.nn import functional as F
class DPCNN(nn.Module):
def __init__(self, trial, vocab_size, class_num):
super(DPCNN, self).__init__()
ci = 1 # input chanel size
kernel_num = 250 # output chanel size
embed_dim = trial.suggest_int("n_embedding", 200, 300, 50)
self.embed = nn.Embedding(vocab_size, embed_dim, padding_idx=1)
self.conv_region = nn.Conv2d(ci, kernel_num, (3, embed_dim), stride=1)
self.conv = nn.Conv2d(kernel_num, kernel_num, (3, 1), stride=1)
self.max_pool = nn.MaxPool2d(kernel_size=(3, 1), stride=2)
self.max_pool_2 = nn.MaxPool2d(kernel_size=(2, 1))
self.padding = nn.ZeroPad2d((0, 0, 1, 1)) # top bottom
self.relu = nn.ReLU()
self.fc = nn.Linear(kernel_num, class_num)
def forward(self, x):
x = self.embed(x) # x: (batch, seq_len, embed_dim)
x = x.unsqueeze(1) # x: (batch, 1, seq_len, embed_dim)
m = self.conv_region(x) # [batch_size, 250, seq_len-3+1, 1]
x = self.padding(m) # [batch_size, 250, seq_len, 1]
x = self.relu(x) # [batch_size, 250, seq_len, 1]
x = self.conv(x) # [batch_size, 250, seq_len-3+1, 1]
x = self.padding(x) # [batch_size, 250, seq_len, 1]
x = self.relu(x) # [batch_size, 250, seq_len, 1]
x = self.conv(x) # [batch_size, 250, seq_len-3+1, 1]
x = x+m
while x.size()[2] > 2:
x = self._block(x)
if x.size()[2] == 2:
x = self.max_pool_2(x) # [batch_size, 250, 1, 1]
x = x.squeeze() # [batch_size, 250]
logit = F.log_softmax(self.fc(x), dim=1)
return logit
def _block(self, x): # for example: [batch_size, 250, 4, 1]
px = self.max_pool(x) # [batch_size, 250, 1, 1]
x = self.padding(px) # [batch_size, 250, 3, 1]
x = F.relu(x)
x = self.conv(x) # [batch_size, 250, 1, 1]
x = self.padding(x)
x = F.relu(x)
x = self.conv(x)
# Short Cut
x = x + px
return
train_eval.py
# -*- coding: utf-8 -*-
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import optuna
from sklearn import metrics
from optuna.trial import TrialState
from model import DPCNN
from load_data import train_iter, val_iter, id2vocab
EPOCHS = 10
CLS = 2
device = "cuda" if torch.cuda.is_available() else 'cpu'
def objective(trial):
model = DPCNN(trial, len(id2vocab), CLS)
model.to(device)
optimizer_name = trial.suggest_categorical("optimizer", ["Adam", "RMSprop", "SGD"])
lr = trial.suggest_float("lr", 1e-5, 1e-1, log=True)
optimizer = getattr(optim, optimizer_name)(model.parameters(), lr=lr)
criterion = nn.NLLLoss()
for epoch in range(EPOCHS):
model.train()
epoch_loss= []
for batch in train_iter:
text_idx_batch, label_idx_batch = batch.text.t_().to(device), batch.label.to(device)
model.zero_grad()
out = model(text_idx_batch)
loss = criterion(out, label_idx_batch)
loss.backward()
epoch_loss.append(loss.item())
optimizer.step()
#print(f'Epoch[{epoch}] - Loss:{sum(epoch_loss)/len(epoch_loss)}')
model.eval()
predict_all = np.array([], dtype=int)
labels_all = np.array([], dtype=int)
with torch.no_grad():
for batch in val_iter:
text_idx_batch, label_idx_batch = batch.text.t_().to(device), batch.label
pred = model(text_idx_batch)
pred = torch.max(pred.data, 1)[1].cpu().numpy()
predict_all = np.append(predict_all, pred)
truth = label_idx_batch.cpu().numpy()
labels_all = np.append(labels_all, truth)
acc = metrics.accuracy_score(labels_all, predict_all)
trial.report(acc, epoch)
if trial.should_prune():
raise optuna.exceptions.TrialPruned()
return acc
if __name__ == '__main__':
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=8)
pruned_trials = study.get_trials(deepcopy=False, states=[TrialState.PRUNED])
complete_trials = study.get_trials(deepcopy=False, states=[TrialState.COMPLETE])
print("Study statistics: ")
print(" Number of finished trials: ", len(study.trials))
print(" Number of pruned trials: ", len(pruned_trials))
print(" Number of complete trials: ", len(complete_trials))
print("Best trial:")
trial = study.best_trial
print(" Value: ", trial.value)
print(" Params: ")
for key, value in trial.params.items():
print(" {}: {}".format(key, value))
相关文章
- DNS原理及其解析过程
- Spring IOC AOP的原理 如果让你自己设计IOC,AOP如何处理(百度)
- 一步步分析为什么B+树适合作为索引的结构 以及索引原理 (阿里面试)
- SAP订单上Shipping抬头和行项目字段的持久化实现原理
- SAP Cloud for Customer对UI界面元素文本的调整原理
- Atitit.数据库表的物理存储结构原理与架构设计与实践
- atitit.条形码的原理与生成总结java Barcode4j barcode o5
- Jetty 的工作原理以及与 Tomcat 的比较
- 深入学习SAP UI5框架代码系列之七:控件数据绑定的三种模式 - One Way, Two Way和OneTime实现原理比较
- SAP UI5 按钮渲染原理
- 视频千倍压缩背后的技术原理之预测技术
- reduce连接是怎么按组合键分组聚合功能原理详解
- ARM-CPU工作原理,基于ARM的SOC讲解
- redux原理是什么