本文主要介绍TextCNN文本分类，主要从TextCNN的原理的Pytorch实现来逐步讲解。主要思想来自论文《Convolutional Neural Networks for Sentence Classification（EMNLP2014）

论文连接：[1408.5882] Convolutional Neural Networks for Sentence Classification (arxiv.org)

目录

一、CNN原理

1.1 卷积计算过程

1.2 激励层与池化层

二、TextCNN文本分类Pytorch实现

2.1 导入包

2.2 参数设置

2.3 数据预处理

2.4 模型构建

2.5 模型训练

2.6 模型测试

---

 

一、CNN原理

卷积神经网络各个层级结构，如下图：

上图中 CNN 要做的事情是：给定一张图片，是车是马还是飞机未知，现在需要模型判断这张图片里具体是一个什么东西

最左边是

• 数据输入层，对数据做一些处理，比如去均值（把输入数据各个维度都中心化为 0，避免数据过多偏差，影响训练效果）、归一化（把所有的数据都归一到同样的范围）、PCA / 白化等等。CNN 只对训练集做 “去均值” 这一步

中间是

• CONV：卷积层 (Convolutional Layer)，线性乘积求和
• RELU：激励层，ReLU 是激活函数的一种
• POOL：池化层 (Pooling Layer)，简言之，即取区域平均值或最大（最小）值

最右边是

• FC：全连接层 (Fully-Connected Layer)

1.1 卷积计算过程

对图像（不同的数据窗口数据）和滤波矩阵（一组固定的权重：因为每个神经元的多个权重固定，所以又可以看做一个恒定的滤波器 filter）做内积（逐个元素相乘再求和）的操作就是所谓的『卷积』操作，也是卷积神经网络的名字来源

举个具体的例子。比如下图中，图中左边部分是原始输入数据，图中中间部分是滤波器 filter，图中右边是输出的新的二维数据，右上角是具体的计算过程

在下图对应的计算过程中，左边是图像输入，中间部分就是滤波器 filter（带着一组固定权重的神经元），不同的滤波器 filter 会得到不同的输出数据，比如颜色深浅、轮廓等。如果想提取图像的不同特征，则可以用不同的滤波器

在 CNN 中，滤波器 filter（带着一组固定权重的神经元）对局部输入数据进行卷积计算。每计算完一个数据窗口内的局部数据后，数据窗口不断平移滑动，直到计算完所有数据。这个过程中，有这么几个参数：

• 深度 depth：即神经元个数，决定输出的 depth 厚度。同时代表滤波器个数
• 步长 stride：决定滑动多少步可以到边缘
• 填充值 zero-padding：在外围边缘补充若干圈 0，方便从初始位置以步长为单位可以刚好滑倒末尾位置，通俗地讲就是为了总长能被步长整除

  

卷积动图

从图中可以看到：

• 有两个神经元，即两个滤波器，depth=2
• 数据窗口每次移动 2 个步长，取 3*3 的局部数据，即 stride=2
• zero-padding=1

然后分别以两个滤波器 filter 为轴滑动数组进行卷积计算，得到两组不同的结果

• 左边是输入（7*7*3 中，7*7 代表图像的长宽，3 代表 RGB 三个颜色通道）
• 中间部分是两个不同的滤波器 Filter w0、Filter w1
• 最右边则是两个不同的输出

随着左边数据窗口的平移滑动，滤波器 Filter w0 / Filter w1 对不同的局部数据进行卷积计算

值得一提的是：左边数据在变化，每次滤波器都是针对某一局部的数据窗口进行卷积，这就是所谓的 CNN 中的局部感知机制。打个比方，滤波器就像一双眼睛，人类视角有限，一眼望去，只能看到这世界的局部。如果一眼就看到全世界，你会累死，而且一下子接受全世界所有信息，你大脑接收不过来

与此同时，数据窗口滑动，导致输入在变化，但中间滤波器 Filter w0 的权重（即每个神经元连接数据窗口的权重）是固定不变的，这个权重不变即所谓的 CNN 中的参数（权重）共享机制

最后提一点，从图上我们可以看到，每个 filter 下面都有一个 bias，因此要在原来的内积计算结束后，再加上这个 bias，得到最终的对应位置值

最后再给一个经过卷积后的图像长宽计算公式

 

1.2 激励层与池化层

激励层

现在绝大部分神经网络采用的激励函数都是 Relu，它的优点是收敛快，求梯度简单，其图形表示如下

池化层（Pooling Layer）

池化，简言之，就是取某个区域的平均值或最大（最小）值，如下图所示

上图所展示的是取区域最大值，即左上角 2x2 的矩阵中 6 最大，右上角 2x2 的矩阵中 8 最大，左下角 2x2 的矩阵中 3 最大，右下角 2x2 的矩阵中 4 最大，所以得到上图右边部分的结果：6 8 3 4

二、TextCNN文本分类Pytorch实现

2.1 导入包

import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as Data
import torch.nn.functional as F

dtype = torch.FloatTensor
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

2.2 参数设置

#(senquence_length = 3)
sentences = ["i love you", "he loves me", "she likes baseball", "i hate you", "sorry for that", "this is awful"]
labels = [1,1,1,0,0,0]

#TextCNN Parameter
embedding_size = 2
sequence_length = len(sentences[0]) # every sentences contains sequence_length(=3) words
num_classes = len(set(labels))  # num_class = 2
batch_size = 3

word_list = " ".join(sentences).split()  # ['i', 'love', 'you', 'he', 'loves', 'me', 'she', 'likes', 'baseball', 'i', 'hate', 'you', 'sorry', 'for', 'that', 'this', 'is', 'awful']
word2idx = {w: i for i ,w in enumerate(vocab)} # {'that': 0, 'loves': 1, 'likes': 2, 'for': 3, 'love': 4, 'sorry': 5, 'she': 6, 'you': 7, 'is': 8, 'me': 9, 'baseball': 10, 'hate': 11, 'he': 12, 'i': 13, 'awful': 14, 'this': 15}
vocab = list(set(word_list))   # ['that', 'loves', 'likes', 'for', 'love', 'sorry', 'she', 'you', 'is', 'me', 'baseball', 'hate', 'he', 'i', 'awful', 'this']
vocab_size = len(vocab)

2.3 数据预处理

def make_data(sentences, labels):
    inputs = []
    # 把每个句子中的单词替换为id  [[13, 4, 7], [12, 1, 9], [6, 2, 10], [13, 11, 7], [5, 3, 0], [15, 8, 14]]
    for sen in sentences:
        inputs.append([word2idx[n] for n in sen.split()])
        
    targets = []
    for out in labels:
        targets.append(out)
    return inputs, targets

# input_batch=[[13, 4, 7], [12, 1, 9], [6, 2, 10], [13, 11, 7], [5, 3, 0], [15, 8, 14]],target_batch=[1, 1, 1, 0, 0, 0]
input_batch, target_batch = make_data(sentences,labels)
"""input_batch=tensor([[13,  4,  7],
        [12,  1,  9],
        [ 6,  2, 10],
        [13, 11,  7],
        [ 5,  3,  0],
        [15,  8, 14]]),target_batch=tensor([1, 1, 1, 0, 0, 0])"""
input_batch, target_batch = torch.LongTensor(input_batch), torch.LongTensor(target_batch)

dataset = Data.TensorDataset(input_batch, target_batch)
loader = Data.DataLoader(dataset, batch_size, True)

2.4 模型构建

class TextCNN(nn.Module):
    def __init__(self):
        super(TextCNN, self).__init__()
        self.W = nn.Embedding(vocab_size, embedding_size)
        output_channel = 3
        
        self.conv = nn.Sequential(
        # conv : [input_channel(=1), out_channel,(filer_height,filter_width),stride=1]
        nn.Conv2d(1, output_channel, (2, embedding_size)),
        nn.ReLU(),
        # pool : ((filter_height, filter_width))
        nn.MaxPool2d((2,1)),
        )
        # fc
        self.fc = nn.Linear(output_channel, num_classes)
    
    def forward(self, X):
        """
        X: [batch_size, sequence_length]
        """
        batch_size = X.shape[0]
        embedding_X = self.W(X) # [batch_size, sequence_length, embedding_size]
        embedding_X = embedding_X.unsqueeze(1) # add channel(=1) [batch, channel(=1),squence_length,embedding_size]
        conved = self.conv(embedding_X) # [batch_size, output_channel*1*1]
        flatten = conved.view(batch_size, -1) # 数据变成batch_size行
        output = self.fc(flatten)
        return output
    

下面详细介绍一下数据在网络中流动的过程中维度的变化。输入数据是个矩阵，矩阵维度为 [batch_size, seqence_length]，输入矩阵的数字代表的是某个词在整个词库中的索引（下标）

首先通过 Embedding 层，也就是查表，将每个索引转为一个向量，比方说 12 可能会变成 [0.3,0.6,0.12,...]，因此整个数据无形中就增加了一个维度，变成了 [batch_size, sequence_length, embedding_size]

之后使用 unsqueeze(1) 函数使数据增加一个维度，变成 [batch_size, 1, sequence_length, embedding_size]。现在的数据才能做卷积，因为在传统 CNN 中，输入数据就应该是 [batch_size, in_channel, height, width] 这种维度

[batch_size, 1, 3, 2] 的输入数据通过 nn.Conv2d(1, 3, (2, 2)) 的卷积之后，得到的就是 [batch_size, 3, 2, 1] 的数据，由于经过 ReLU 激活函数是不改变维度的，所以就没画出来。最后经过一个 nn.MaxPool2d((2, 1)) 池化，得到的数据维度就是 [batch_size, 3, 1, 1]

2.5 模型训练

model = TextCNN().to(device)
criterion = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr = 1e-3)

#Training
for epoch in range(5000):
    for batch_x, batch_y in loader:
        batch_x, batch_y = batch_x.to(device), batch_y.to(device)
        pred = model(batch_x)
        loss = criterion(pred, batch_y)
        if (epoch + 1) % 1000 == 0:
            print('Epoch:', '%04d'%(epoch + 1),'loss = ','{:.6f}'.format(loss))
            
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

打印结果

Epoch: 1000 loss =  0.004997
Epoch: 1000 loss =  0.003771
Epoch: 2000 loss =  0.000500
Epoch: 2000 loss =  0.000527
Epoch: 3000 loss =  0.000079
Epoch: 3000 loss =  0.000158
Epoch: 4000 loss =  0.000048
Epoch: 4000 loss =  0.000019
Epoch: 5000 loss =  0.000010
Epoch: 5000 loss =  0.000010

2.6 模型测试

# Test
test_text = 'i hate me'
tests = [[word2idx[n] for n in test_text.split()]]
test_batch = torch.LongTensor(tests).to(device)
# Predict
model = model.eval()
predict = model(test_batch).data.max(1, keepdim=True)[1]
if predict[0][0] == 0:
    print(test_text,"is Bad Mean...")
else:
    print(test_text,"is Good Mean!!")

打印结果

i hate me is Bad Mean...

预测成功！

参考

1. CS231n笔记：通俗理解CNN - mathor (wmathor.com)

2. TextCNN的PyTorch实现 - mathor (wmathor.com)