从头学pytorch(十七):网络中的网络NIN
网络中的网络NIN
之前介绍的LeNet,AlexNet,VGG设计思路上的共同之处,是加宽(增加卷积层的输出的channel数量)和加深(增加卷积层的数量),再接全连接层做分类.
NIN提出了一个不同的思路,串联多个由卷积层和'全连接层'(1x1卷积)构成的小网络来构建一个深层网络.
论文地址:https://arxiv.org/pdf/1312.4400.pdf
nin的重点我总结主要就2点:
- mlpconv的提出(我们用1x1卷积实现),整合多个feature map上的特征．进一步增强非线性．
- 全局平均池化替代全连接层
推荐一篇我觉得不错的解读博客:https://blog.csdn.net/hjimce/article/details/50458190
1x1卷积
1x1卷积对channel维度上的元素做乘加操作.
如上图所示,由于1x1卷积对空间维度上的元素并没有做关联,所以空间维度(h,w)上的信息得以传递到后面的层中.
举个例子,以[h,w,c]这种顺序为例,1x1卷积只会将[0,0,0],[0,0,1],[0,0,2]做乘加操作.
[0,0,x]的元素和[0,1,x]的元素是不会发生关系的.
NIN结构
NIN Net是在AlexNet的基础上提出的他们的结构分别如下所示:
AlexNet结构如下:
注意,这个图里的maxpool是在第一二五个卷积层以后.这个图稍微有点误导.即11x11的卷积核后做maxpool,再做卷积.而不是卷积-卷积-池化.
NIN结构如下:
这是网上找的一个示意图,nin的论文里并没有完整的结构图.
这个图有一点不对,最后一个卷积那里应该用的卷积核的shape应该是3x3x384.共1000个,下图红圈处应该是3x3x384x1000,1000,1000.对应到我们的实现,应该是3x3x384x10,10,10．因为我们的数据集只有10个类别.
下面我们先来实现卷积部分:
首先我们定义nin的'小网络'模块．即'常规卷积-1x1卷积-1x1卷积'这一部分.
def make_layers(in_channels,out_channels,kernel_size, stride, padding):
conv = nn.Sequential(
nn.Conv2d(in_channels,out_channels,kernel_size, stride, padding),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels,out_channels,kernel_size=1, stride=1, padding=0),#1x1卷积,整合多个feature map的特征
nn.ReLU(inplace=True),
nn.Conv2d(out_channels,out_channels,kernel_size=1, stride=1, padding=0),#1x1卷积,整合多个feature map的特征
nn.ReLU(inplace=True)
)
return conv
然后对于网络的卷积部分,我们就可以写出如下代码
conv1 = make_layers(1,96,11,4,2)
pool1 = nn.MaxPool2d(kernel_size=3,stride=2)
conv2 = make_layers(96,256,kernel_size=5,stride=1,padding=2)
pool2 = nn.MaxPool2d(kernel_size=3,stride=2)
conv3 = make_layers(256,384,kernel_size=3,stride=1,padding=1)
pool3 = nn.MaxPool2d(kernel_size=3,stride=2)
conv4 = make_layers(384,10,kernel_size=3,stride=1,padding=1)
我们来验证一下模型
X = torch.rand(1, 1, 224, 224)
o1 = conv1(X)
print(o1.shape) #[1,96,55,55]
o1_1 = pool1(o1)
print(o1_1.shape) #[1,96,27,27]
o2 = conv2(o1_1)
print(o2.shape) #[1,256,27,27]
o2_1 = pool2(o2)
print(o2_1.shape) #[1,256,13,13]
o3 = conv3(o2_1)
print(o3.shape) #[1,384,13,13]
o3_1 = pool3(o3)
print(o3_1.shape) #[1,384,6,6]
o4 = conv4(o3_1)
print(o4.shape) #[1,10,6,6]
每一层的输出shape都是对的,说明我们模型写对了.如果不对,我们就去调整make_layers()的参数,主要是padding.
卷积部分得到[1,10,6,6]的输出以后,我们要做一个全局平均池化,全局平均池化什么意思呢?
我们先看普通池化,比方说一个10x10的输入,用2x2的窗口去做池化,然后这个窗口不断地滑动,从而对不同的2x2区域可以做求平均(平均池化),取最大值(最大值池化)等.这个就可以理解为'局部'的池化,2x2是10x10的一部分嘛.
相应地,所谓全局池化,自然就是用一个和输入大小一样的窗口做池化,即对全部的输入做池化操作.
所以我们可以实现出全局平均池化部分:
ap = nn.AvgPool2d(kernel_size=6,stride=1)
o5 = ap(o4)
print(o5.shape) #[1,10,1,1]
torch中的nn模块已经提供了平均池化操作函数,我们要做的就是把kernel_size赋值成和输入的feature map的size一样大小就好了,这样就实现了全局平均池化.
全局平均池化的重要意义
用全局平均池化替代全连接层,一个显而易见的好处就是,参数量极大地减少了,从而也防止了过拟合.
另一个角度看,是从网络结构上做正则化防止过拟合.比方说[1,10,6,6]的输入,即10个6x6的feature map,我们做全局平均池化后得到[1,10,1,1]的输出,展平后即10x1的输出,这10个标量,我们认为代表十个类别.训练的过程就是使这十个标量不断逼近代表真实类别的标量的过程.这使得模型的可解释性更好了．
参考:https://zhuanlan.zhihu.com/p/46235425
基于以上讨论,我们可以给出NinNet定义如下:
class ＮinNet(nn.Module):
def __init__(self):
super(ＮinNet, self).__init__()
self.conv = nn.Sequential(
make_layers(1,96,11,4,2),
nn.MaxPool2d(kernel_size=3,stride=2),
make_layers(96,256,kernel_size=5,stride=1,padding=2),
nn.MaxPool2d(kernel_size=3,stride=2),
make_layers(256,384,kernel_size=3,stride=1,padding=1),
nn.MaxPool2d(kernel_size=3,stride=2),
make_layers(384,10,kernel_size=3,stride=1,padding=1)
)
self.gap = nn.Sequential(
nn.AvgPool2d(kernel_size=6,stride=1)
)
def forward(self, img):
feature = self.conv(img)
output = self.gap(feature)
output = output.view(img.shape[0],-1)#[batch,10,1,1]-->[batch,10]
return output
我们可以简单测试一下:
X = torch.rand(1, 1, 224, 224)
net = ＮinNet()
for name,module in net.named_children():
X = module(X)
print(name,X.shape)
输出
conv torch.Size([1, 10, 6, 6])
gap torch.Size([1, 10, 1, 1])
接下来就是熟悉的套路:
加载数据
batch_size,num_workers=16,4
train_iter,test_iter = learntorch_utils.load_data(batch_size,num_workers,resize=224)
定义模型
net = ＮinNet().cuda()
print(net)
定义损失函数
loss = nn.CrossEntropyLoss()
定义优化器
opt = torch.optim.Adam(net.parameters(),lr=0.001)
定义评估函数
def test():
start = time.time()
acc_sum = 0
batch = 0
for X,y in test_iter:
X,y = X.cuda(),y.cuda()
y_hat = net(X)
acc_sum += (y_hat.argmax(dim=1) == y).float().sum().item()
batch += 1
#print('acc_sum %d,batch %d' % (acc_sum,batch))
acc = 1.0*acc_sum/(batch*batch_size)
end = time.time()
print('acc %3f,test for test dataset:time %d' % (acc,end - start))
return acc
训练
num_epochs = 3
def train():
for epoch in range(num_epochs):
train_l_sum,batch,acc_sum = 0,0,0
start = time.time()
for X,y in train_iter:
# start_batch_begin = time.time()
X,y = X.cuda(),y.cuda()
y_hat = net(X)
acc_sum += (y_hat.argmax(dim=1) == y).float().sum().item()
l = loss(y_hat,y)
opt.zero_grad()
l.backward()
opt.step()
train_l_sum += l.item()
batch += 1
mean_loss = train_l_sum/(batch*batch_size) #计算平均到每张图片的loss
start_batch_end = time.time()
time_batch = start_batch_end - start
train_acc = acc_sum/(batch*batch_size)
if batch % 100 == 0:
print('epoch %d,batch %d,train_loss %.3f,train_acc:%.3f,time %.3f' %
(epoch,batch,mean_loss,train_acc,time_batch))
if batch % 1000 == 0:
model_state = net.state_dict()
model_name = 'nin_epoch_%d_batch_%d_acc_%.2f.pt' % (epoch,batch,train_acc)
torch.save(model_state,model_name)
print('***************************************')
mean_loss = train_l_sum/(batch*batch_size) #计算平均到每张图片的loss
train_acc = acc_sum/(batch*batch_size) #计算训练准确率
test_acc = test() #计算测试准确率
end = time.time()
time_per_epoch = end - start
print('epoch %d,train_loss %f,train_acc %f,test_acc %f,time %f' %
(epoch + 1,mean_loss,train_acc,test_acc,time_per_epoch))
train()
部分输出如下
epoch 0,batch 3600,train_loss 0.070,train_acc:0.603,time 176.200
epoch 0,batch 3700,train_loss 0.069,train_acc:0.606,time 181.160
***************************************
acc 0.701800,test for test dataset:time 11
epoch 1,train_loss 0.069109,train_acc 0.607550,test_acc 0.701800,time 195.619591
epoch 1,batch 100,train_loss 0.044,train_acc:0.736,time 5.053
epoch 1,batch 200,train_loss 0.047,train_acc:0.727,time 10.011
epoch 1,batch 300,train_loss 0.048,train_acc:0.735,time 15.210
可以看到由于没有了全连接层,训练时间明显缩短.
