🍊文本从如何识别出图片中的小女孩引入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深度学习实战》刘二大人