编辑

🍊文本从如何识别出图片中的小女孩引入CNN，将其与FNN进行对比，并对CNN网络模型进行了详细的介绍。最后在自然语言处理和视觉领域进行实战。具体来说，使用CNN组合的四个经典模型对Mnist数据集进行图像分类，使用TextCNN对IMDB数据集进行文本分类

🍊实验一：模拟CNN，并观察其输入、卷积层、输出的维度情况

🍊实验二：图像分类--LeNet-5模型

🍊实验三：图像分类--AlexNet模型（改编版）

🍊实验四：图像分类--VGG16模型

🍊实验五：图像分类--GoogleNet模型

🍊实验六：文本分类--TextCNN模型

一、Introduction

假如有这样一张图片，我们是如何检测出图片中的小女孩呢？我们可以将图片分割成一个个小部分，对每个小部分来检测嘴巴、鼻子、眼睛，最后进行总体的判断。如此图像检测的流程就是CNN

编辑

在介绍CNN之前，我们先来看FNN有什么缺点。

缺点一：参数太多，因为FNN是全连接的，它的权重参数需要训练的数量是非常大的，比如有一个图像的尺寸是128*128*3，那么每一次层的神经元和权重参数就有128*128*3个，如此巨大的参数在实际训练过程中效率非常低下。

缺点二：局部不变性，FNN如果不进行数据增强的话是很那提取到对象的关键信息

而CNN的产生就是为了解决以上的两个问题，即权重比较少的FNN。

编辑

二、Convolutional Layer

如何判断一个网络层是CNN呢？如果一个网络层对输入使用了Receptive Field和Parameters Sharing，那么这样的神经网络的架构就是CNN

编辑

我们拿一张图片的简化来举例子，首先神经网络的输入一定是一个向量，但是图片是一个三维（length、width、RGB）的Tensor矩阵，因此我们需要将此Tensor转化为100*100*3的向量。这么大的向量如果输入到模型中其权重w也非常大，因此我们需要对其进行简化

2.1 Receptive field

假如有一张图片，我们如何判断里面是否有小鸟，我们实际上不需要知道整张图片的细节，只需要知道关键的区分点，即特征

编辑

因此，我们可以将原始图片即一个大的三维Tensor分割成一个个小的三维Tensor，这里每个Tensor就是一个Receptive field（也被称作卷积核kernels）

随后将每个Receptive field放到一个单独的网络层中

编辑

因为一张图片中的任何位置都有可能有我们想要检测的目标，因此Receptive field需要覆盖整张图片，因此我们需要设置一个超参数stride步幅来控制覆盖图片的速度

在覆盖过程中，可能遇到一些边边角角难以适配（与stride超参数有关），那么我们可以覆盖上，超出的部分使用padding补齐，一般使用0或整张图片的平均值来补齐。此外，还有很多时候我们想用padding是因为想将图像变大

编辑

2.2 Parameters sharing

如果我们只想检测喙，我们需要使用receptive field覆盖整张图片来搜索检测，每个receptive field都有检测喙功能的neurons。

编辑

因为它们的主要功能就是检测喙，只是检测的图像区域不一样罢了，因此我们可以进行优化，即权重共享参数。如此可以共享权重的神经元就叫做filter

编辑

2.3 Pooling

还有一个简化的方法就是对图片进行压缩，比如说删除掉图片长度为奇数，RGB中的red，虽然图像的画质降低了，但是总体上我们还是能识别该图像。这就是Pooling技术。

但是如今不怎么使用了，虽然Pooling在一定程度上可以获取重要信息而舍去边缘信息，从而减少计算开销，但是Pooling同时是以牺牲精度为代价来提高训练速度，现在机器的算力如此强悍，这点训练时间不算什么

将一个Tensor分割成很多小Tensor，每个小Tensor取一个值来合并成一个大Tensor，取值主要有三种方法

Mean-Pooling	取平均值
Max-Pooling	取最大值
Stochastic-pooling	轮盘法取值

MaxPooling技术

编辑

2.4 Convolution Algorithm

在CNN中有一个独特的计算方式叫做卷积计算，其符号的表示和乘法一样都是*，其计算过程如下图中，橙色图为待计算初始图，我们选中一个Receptive field，绿色图为一个filter。

2*1+3*0+2*(-1)+1*1+0*0+3*(-1)+1*1+2*0+3*(-1)=-4

编辑

随后对其他图也进行卷积计算，最终一个channel计算的结果如下，将所有channels相加起来就是最终的输出

编辑

如果你的数学敏感性比较高，可以发现

1 若没有进行padding操作，卷积后的Tensor的尺寸=原图尺寸-Filter尺寸+1

2 卷积核的有多少个，输出Tensor的channels就有多少层

最后，再放上一张卷积计算的总过程

编辑

2.5 Calculation skill

在学CNN的时候大家最烦的莫过于图像尺寸的变化，Padding、Kernal、Stride到底怎么计算？其实这样是有一个计算公式的如下

编辑

N：输出大小

W：输入图片大小

F：kernel大小

S：步长

P：补缺数量

2.6 Total flow

1 根据对象特征设计好一个个Filter

2 在图片中取出一个个Receptive Field数据，将与Filter进行卷积运算，得到一个具体的数值，将这些数值组合起来形成一个二维Tensor

3 将2得到的2维Tensor结合起来得到一个高维的Tensor，称之为Feature Map

4 使用Pooling技术将Tensor压缩（经典做法为其进入几个卷积层之后做一次Pooling）

5 到这里卷积结束了，但是它是无法直接连接Dense全连接层的，需要将Convolution层的数据压平Flatten为一维数据

6 最后放到一个FNN中进行分类预测

编辑

2.7 GoogleNet

我们先看看整个整个网络模型的架构

编辑

咋一看是不是感觉头皮发麻，怎么这个网络模型这么复杂，但是仔细看看会发现可以将其分成许多小模块，这些小模块很多都是重复的，如下图中所示

这个可复用的小模块称之为Inceptioin。

编辑

那为什么要设计这样Inception呢？

我们在设计CNN网络模型的时候，卷积核的参数、卷积层的个数等超参数都难以确定，Inception就是为了解决这个问题。具体的做法的思想是我们不知道哪种CNN比较好，就设计四个如下图的CNN模型，都放进Inception中，哪个效果最好哪个权重就比较高。

作者感觉这与集成学习中的软投票做法一致

编辑

使用四个模型计算出了四个Tensor后，还需要使用Concatenate方法将其拼接在一起，实践操作就是使用cat函数

Inception中有一个非常有意思的东西就是1*1 Conv，它计算的过程如下

编辑

是不是感觉像一个美颜滤镜，对每个图层进行美化，最后合并成一个图层？是的，它的作用是直接压缩Tensor的Channels

2.8 TextCNN

CNN一般都是用于CV领域中，而深度学习中主流研究对象还有NLP，那CNN可以用在NLP中吗？当然可以，直观的讲，CNN就是一个滑窗，图像是一个矩形，所以滑窗也是个矩形，而文本是一个向量，因此滑窗就是个向量。

早在2014年就有人提出了TextCNN，其模型如下

编辑

欸，看起来可能有点抽象，看另一篇解释该模型的图可能好理解多了

编辑

首先原句与卷积核分别为[2，768]、[3,768]、[4,768]且channels为2的filtet进行卷积运算得到6个一维向量
随后将每个一维向量中取出最大值，将这6个最大值拼接成[6，2]的Tensor
最后进行常规的分类预测

三、Experiment

3.1 实验一：模拟CNN观察各网络层尺寸

题目：自定义输入图片尺寸，卷积核数量，观察CNN输入、卷积层、输出的各个尺寸分别为多少？

import torch
in_channel, out_channel = 5, 10  # 输入输出的channel
width, height = 100, 100  # 一张照片的长宽
kernel_size = 3  # 卷积核的数量
batch_size = 1  # 当前训练的batch序号
input = torch.randn(batch_size, in_channel, width, height)  # 假设有一张照片输入进来
conv_layer = torch.nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size)  # 定义卷积层
output = conv_layer(input)
print(input.shape)
print(output.shape)
print(conv_layer.weight.shape)

Result

编辑

1 输入的channel为5，输出的channel为10，而卷积层的卷积核的channel为5，一共有10个

2 该CNN没有Padding操作，输出尺寸98=输入尺寸100-filter尺寸3+1

3.2 Mnist数据集

数据集我们是使用torchvision，torchvision是专门服务于Pytorch的图形库

torchvision.datasets：加载图形数据集

tramsforms.Compose：各类图片变换，如裁剪，旋转，标准化。按照左到右顺序进行转换

transforms.ToTensor：转换一张图片或Numpy数组为Tensor张量类型

transforms.Normalize：使用平均值和标准误差来标准化图片，其中0.1307和0.3081超参数是官方提供的

MNIST数据集是手写数字的图片，通过以下代码测试，我们可以发现该数据集的训练集一共有60k条，测试集有10k条，每条数据由28*28的图片构成

print('test_loader.dataset',test_loader.dataset)
    print('train_loader.dataset',train_loader.dataset)
    imgs,_=next(iter(test_loader))
    print(imgs.shape)

编辑

3.3 实验二：LeNet-5 模型

实验二：构建LeNet-5模型对经典手写数字Mnist数据集进行分类识别

神经网络架构图

编辑

Code

import torch
from torch import nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# Prepare for the datasets
batch_size = 64
EPOCH = 100
transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])  # Transform picture to tensor
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
class LeNet(torch.nn.Module):
    def __init__(self):
        super(LeNet,self).__init__()
        self.conv=nn.Sequential(
            nn.Conv2d(1,6,5),
            nn.Sigmoid(),
            nn.MaxPool2d(2,2),
            nn.Conv2d(6,16,5),
            nn.Sigmoid(),
            nn.MaxPool2d(2,2)
        )
        self.fc=nn.Sequential(
            nn.Linear(16*4*4,120),
            nn.Sigmoid(),
            nn.Linear(120,84),
            nn.Sigmoid(),
            nn.Linear(84,10)
        )
    def forward(self,x):
        batch_size=x.size(0)# Get the batch_size
        x=self.conv(x)
        x=x.view(batch_size, -1)
        x=self.fc(x)
        return x
model = LeNet()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# Define criterion and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # momentum是动量,主要解决初始化数值特殊陷入局部最优问题
def train(epoch):
    running_loss = 0.0
    for batch_index, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        running_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if batch_index % 200 == 199:
            print('Epoch:[%d/%d] batch_index: %d loss: %.6f' % (epoch + 1, EPOCH, batch_index + 1, running_loss / 300))
            running_loss = 0.0
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)  # outputs.shape=[64,10]
            _, predicted = torch.max(outputs.data, dim=1)  # predicted.shape=[64]
            total += labels.size(0)  # Add every batch.size
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %.6f %% ' % (100 * correct / total))
    return correct / total
if __name__ == '__main__':
    epoch_list = []
    acc_list = []
    for epoch in range(EPOCH):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)
    plt.plot(epoch_list, acc_list)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.show()

Result

编辑

最终准确率在98%左右

3.4 实验三：AlexNet 模型（改编版）

实验三：构建AlexN模型改编版对经典手写数字Mnist数据集进行分类识别

神经网络架构图

我们使用了3个CNN，将其串行连接，随后将其Flatten成一维向量，放入到两个FNN中进行下游分类任务

这里的两个FNN都没有加激活函数，大家可能会对此感到疑惑，其实这主要是因为该数据集和网络模型过于简单，更符合于线性规则

编辑

代码

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# Prepare for the datasets
batch_size = 64
EPOCH = 10
transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])  # Transform picture to tensor
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
# Define the CNN_model
class CNN_Net(torch.nn.Module):
    def __init__(self):
        super(CNN_Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=3)
        self.conv3 = torch.nn.Conv2d(20, 40, kernel_size=2)
        self.pooling = torch.nn.MaxPool2d(2)
        self.fc1 = torch.nn.Linear(640, 160)
        self.fc2 = torch.nn.Linear(160, 10)
    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))  # conv1+pooling
        x = F.relu(self.pooling(self.conv2(x)))  # conv2+pooling
        x = F.relu(self.conv3(x))
        x = x.view(batch_size, -1)  # flatten
        x = self.fc1(x)  # FNN
        x = self.fc2(x)
        return x
model = CNN_Net()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# Define criterion and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # momentum是动量,主要解决初始化数值特殊陷入局部最优问题
def train(epoch):
    running_loss = 0.0
    for batch_index, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        running_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if batch_index % 200 == 199:
            print('Epoch:[%d/%d] batch_index: %d loss: %.6f' % (epoch + 1,EPOCH, batch_index + 1, running_loss / 300))
            running_loss = 0.0
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)  # outputs.shape=[64,10]
            _, predicted = torch.max(outputs.data, dim=1)  # predicted.shape=[64]
            total += labels.size(0)  # Add every batch.size
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %.6f %% ' % (100 * correct / total))
    return correct / total
if __name__ == '__main__':
    epoch_list = []
    acc_list = []
    for epoch in range(EPOCH):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)
    plt.plot(epoch_list, acc_list)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.show()

Result

编辑

可以看到随着训练的进行，该网络模型准确率上升，最终达到了99.12%

3.5 实验四：VGG16模型

题目：构建GoogleNet模型来对Mnist模型进行分类预测

首先看看VGG16的原始模型长啥样

编辑

其实也非常简单，只用(2,2)或(3,3)卷积核的卷积层和Pool(2,2)的池化层进行拼接

但是由于我们的图像是28*28的，因此我对原始模型进行了部分的小改

首先将28*28的图像扩展为64*64的，28*28实在玩不动这么多卷积的网络模型！

网络架构图

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# Prepare for the datasets
batch_size = 64
EPOCH = 10
transform_VGG16 = transforms.Compose([transforms.Resize([64, 64]),
                                        transforms.ToTensor()])
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform_VGG16)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform_VGG16)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
# Define the CNN_model
class VGG16(torch.nn.Module):
    def __init__(self):
        super(VGG16, self).__init__()
        self.block1 = nn.Sequential(
            nn.Conv2d(1, 64, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(64, 64, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.block2 = nn.Sequential(
            nn.Conv2d(64, 128, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(128, 128, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.block3 = nn.Sequential(
            nn.Conv2d(128, 256, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(256, 256, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(256, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.block4 = nn.Sequential(
            nn.Conv2d(256, 512, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(512, 512, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(512, 512, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.block5 = nn.Sequential(
            nn.Conv2d(512, 512, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(512, 512, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(512, 512, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.fnn = nn.Sequential(
            nn.Linear(2 * 2 * 512, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 10)
        )
    def forward(self, x):
        batch_size = x.size(0)
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = x.view(batch_size, -1)
        x = self.fnn(x)
        return x
model = VGG16()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# Define criterion and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # momentum是动量,主要解决初始化数值特殊陷入局部最优问题
def train(epoch):
    running_loss = 0.0
    for batch_index, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        running_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if batch_index % 200 == 199:
            print('Epoch:[%d/%d] batch_index: %d loss: %.6f' % (epoch + 1,EPOCH, batch_index + 1, running_loss / 300))
            running_loss = 0.0
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)  # outputs.shape=[64,10]
            _, predicted = torch.max(outputs.data, dim=1)  # predicted.shape=[64]
            total += labels.size(0)  # Add every batch.size
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %.6f %% ' % (100 * correct / total))
    return correct / total
if __name__ == '__main__':
    epoch_list = []
    acc_list = []
    for epoch in range(EPOCH):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)
    plt.plot(epoch_list, acc_list)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.show()

编辑

最终的准确率也是在99%左右

3.6 实验五：GoogleNet模型

题目：构建GoogleNet模型来对Mnist模型进行分类预测

import torch
from torch import nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# Prepare for the datasets
batch_size = 64
EPOCH = 30
transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])  # Transform picture to tensor
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
# GoogleNet_Inception
class InceptionA(nn.Module):
    def __init__(self, in_channels):
        super(InceptionA, self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch5x5_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch5x5_2 = nn.Conv2d(16, 24, kernel_size=5, padding=2)
        self.branch3x3_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch3x3_2 = nn.Conv2d(16, 24, kernel_size=3, padding=1)
        self.branch3x3_3 = nn.Conv2d(24, 24, kernel_size=3, padding=1)
        self.branch_pool = nn.Conv2d(in_channels, 24, kernel_size=1)
    def forward(self, x):
        branch1x1 = self.branch1x1(x)
        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)
        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)
        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)
        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
        return torch.cat(outputs, dim=1)  # b,c,w,h  c对应的是dim=1
class GoogleNet(nn.Module):
    def __init__(self):
        super(GoogleNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(88, 20, kernel_size=5)  # 88 = 24x3 + 16
        self.incep1 = InceptionA(in_channels=10)  # 与conv1 中的10对应
        self.incep2 = InceptionA(in_channels=20)  # 与conv2 中的20对应
        self.mp = nn.MaxPool2d(2)
        self.fc = nn.Linear(1408, 10)
    def forward(self, x):
        in_size = x.size(0)
        x = F.relu(self.mp(self.conv1(x)))
        x = self.incep1(x)
        x = F.relu(self.mp(self.conv2(x)))
        x = self.incep2(x)
        x = x.view(in_size, -1)
        x = self.fc(x)
        return x
model = GoogleNet()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# Define criterion and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # momentum是动量,主要解决初始化数值特殊陷入局部最优问题
def train(epoch):
    running_loss = 0.0
    for batch_index, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        running_loss += loss.item()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if batch_index % 200 == 199:
            print('Epoch:[%d/%d] batch_index: %d loss: %.6f' % (epoch + 1, EPOCH, batch_index + 1, running_loss / 300))
            running_loss = 0.0
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)  # outputs.shape=[64,10]
            _, predicted = torch.max(outputs.data, dim=1)  # predicted.shape=[64]
            total += labels.size(0)  # Add every batch.size
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %.6f %% ' % (100 * correct / total))
    return correct / total
if __name__ == '__main__':
    epoch_list = []
    acc_list = []
    for epoch in range(EPOCH):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)
    plt.plot(epoch_list, acc_list)
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.show()

Result

编辑

最终的准确率也在99%左右

3.7 实验六：TextCnn

题目：使用Bert+TextCNN对IMDB进行文本情感分析

该题的完整工程代码可参考这篇文章，在本节中只描述TextCNN代码模块

class TextCNN_Model(nn.Module):
    def __init__(self, base_model, num_classes):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        for param in base_model.parameters():
            param.requires_grad = (True)
        # Define the hyperparameters
        self.filter_sizes = [2, 3, 4]
        self.num_filters = 2
        self.encode_layer = 12
        # TextCNN
        self.convs = nn.ModuleList(
            [nn.Conv2d(in_channels=1, out_channels=self.num_filters,
                       kernel_size=(K, self.base_model.config.hidden_size)) for K in self.filter_sizes]
        )
        self.block = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(self.num_filters * len(self.filter_sizes), self.num_classes),
            nn.Softmax(dim=1)
        )
    def conv_pool(self, tokens, conv):
        tokens = conv(tokens)
        tokens = F.relu(tokens)
        tokens = tokens.squeeze(3)
        tokens = F.max_pool1d(tokens, tokens.size(2))
        out = tokens.squeeze(2)
        return out
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state.unsqueeze(1)
        out = torch.cat([self.conv_pool(tokens, conv) for conv in self.convs],
                        1)
        predicts = self.block(out)
        return predicts

其准确率也是可以达到92.30%

参考资料

《机器学习》周志华

《深度学习与机器学习》吴恩达

《神经网络与与深度学习》邱锡鹏

《Pytorch深度学习实战》刘二大人

【Deep Learning 6】CNN卷积神经网络

一、Introduction

二、Convolutional Layer

2.1 Receptive field

2.2 Parameters sharing

2.3 Pooling

2.4 Convolution Algorithm

2.5 Calculation skill

2.6 Total flow

2.7 GoogleNet

2.8 TextCNN

三、Experiment

3.1 实验一：模拟CNN观察各网络层尺寸

3.2 Mnist数据集

3.3 实验二：LeNet-5 模型

3.4 实验三：AlexNet 模型（改编版）

3.5 实验四：VGG16模型

3.6 实验五：GoogleNet模型

3.7 实验六：TextCnn

大数据与机器学习

热门文章

最新文章

相关课程

相关电子书

相关实验场景