本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.
1. 串行的网络结构
之前的网络结构，不管是全连接神经网络还是卷积神经网络，都是一种串行的结构。
2. GoogLeNet
2.1 结构分析
如上图所示，网络结构其实有很多重复的地方，因此为了减少代码冗余，会使用函数/类。
GooleNet的网络结构，里面的模块称为inception，如下所示：
inception模块的构成方式其实有很多种，这只是其中的一种。首先需要知道inception为什幺这样构建？
因为构建的时候有一些超参数是比较难选的，比如卷积核的大小，是使用3×3，还是5×5还是使用其他的方式。
GooleNet的出发点就是不知道哪个卷积核好用，那幺就在一个块里面把卷积核都使用一下，然后把他们结果挪到一起，之后如果3×3的好用，自然3×3的权重就会变得比较大，其他路线的权重相对就会变得更小，所以这是提供了几种后续的神经网络的配置，然后通过训练自动的找到最优的卷积的组合。
Concatenate：把张量拼接到一块。4条路径算出来4个张量，所以肯定要做一个拼接。
Average Pooling：均值池化，4条分支后续要进行拼接，所以必须要保持他们的宽度和高度是一致的，输出的图像格式为（B,C,W,H），唯一可以不同的就是C（channel），不同的卷积核为了使得输出的W和H一致，可以通过padding来实现。
之前使用的是2×2的最大池化，导致图像变成了原来的一半，所以解决方案是做池化的时候认为的指定stride=1，padding= 多少。例如使用3×3的大小去做均值，可以使用padding=1，有点类似卷积的操作，但是没有卷积核，使用的可以称为均值卷积核，卷积核中的数都一样，所以均值池化可以通过设置stride和padding使得输入输出图像的大小是一致的。
1×1的卷积：代表卷积核大小就是1×1的，1×1卷积的个数取决于输出张量的通道数。
1×1的卷积完成了一个信息融合，其主要工作就是改变通道数，减小复杂度。
神经网络里面的问题就是运算量太大，所以我们需要思考怎幺解决运算量大的问题。在原来的基础上添加了一层1×1的卷积层之后，运算量变为了原来的1/10。
inception实现
ps：上图最后一行少了branch = self.branch3x3_3(branch3x3)
在各个计算完成之后还需要拼接，按照各个通道进行拼接，如图所示：
2.2 代码实现
# inception模块
class Inception(nn.Module):
def __init__(self,in_channels):
super(Inception, self).__init__()
self.branch1x1 = nn.Conv2d(in_channels,16,kernel_size=1)
self.branch5x1 = nn.Conv2d(in_channels,16,kernel_size=1)
self.branch5x2 = nn.Conv2d(16,24,kernel_size=5,padding=2)
self.branch3x1 = nn.Conv2d(in_channels,16,kernel_size=1)
self.branch3x2 = nn.Conv2d(16,24,kernel_size=3,padding=1)
self.branch3x3 = 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.branch5x1(x)
branch5x5 = self.branch5x2(branch5x5)
branch3x3 = self.branch3x1(x)
branch3x3 = self.branch3x2(branch3x3)
branch3x3 = self.branch3x3(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) # 按通道进行拼接
注意：初始的输入通道没有写死，而是作为in_channels入参设置。
# 网络模块
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1,10,kernel_size=5)
self.conv2 = nn.Conv2d(88,20,kernel_size=5)
self.incep1 = Inception(in_channels=10)
self.incep2 = Inception(in_channels=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))) # 10通道
x = self.incep1(x) # 10通道变88通道
x = f.relu(self.mp(self.conv2(x))) # 88通道变20通道
x = self.incep2(x) # 20通道变88通道
x = x.view(in_size,-1) # 这里可以计算出拉成一维以后的大小
x = self.fc(x)
return x
2.3 结果
使用MNIST数据集测试Inception网络模型，结果如下：
性能略微提升，说明改变卷积层的结构还是有效果。此外，观察结果图可以发现，准确率上升到最高点后出现了下降。
注意：一般我们在训练的过程中，我们会保存我们每个epoch训练的结果，最后我们会在测试集上选用准确率高的训练模型。我们需要注意的是不是说训练的次数越多，网络的性能越好，训练的多了可能出现过拟合，导致模型的泛化能力变差。
3. ResNet
3.1 网络分析
叠加卷积层，效果会更好吗？把3×3的网络一直堆下去，实验发现层数越多，反而错误率越高。
思考可能是梯度消失，因为我们的网络会进行反向传播，而反向传播的本质是链式法则。假如一连串的梯度是小于1的，这样乘起来就会越来越小，最终趋近于0。
而我们的权重更新是：w = w – 学习率*梯度，如果梯度接近0了，那幺他们的权重w就基本得不到什幺更新。
解决梯度消失的思路：
假如有一个512的隐藏层，然后后面直接接一个512×10的层进行训练，训练完成以后，把512层进行冻结;
然后再添加一个256的层，后面接256×10进行训练，训练完成以后，还是对256层进行加锁，逐层的进行训练。
通过以上这种训练方式来解决梯度消失的问题。 但是在深度学习里面，这样做的话其实是一件很困难的事情，因为深度学习的层数是非常多的。
ResNet引入残差结构以解决网路层数加深时导致的梯度消失问题。通过短路连接，可以实现在计算梯度的时候不至于接近0，而是梯度小的时候，计算的梯度值在1附近，这就是Resnet网络的智慧所在。
3.2 代码实现
残差模块代码实现：
# ResidualBlock模块
class ResidualBlock(nn.Module):
def __init__(self,channels):
super(ResidualBlock, self).__init__()
self.channels = channels
self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
def forward(self,x):
y = f.relu(self.conv1(x))
y = self.conv2(y)
return f.relu(x+y)
网络结构代码实现：
# 网络模块
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.conv1 = nn.Conv2d(1,16,kernel_size=5)
self.conv2 = nn.Conv2d(16,32,kernel_size=5)
self.mp = nn.MaxPool2d(2)
self.rblock1 = ResidualBlock(16)
self.rblock2 = ResidualBlock(32)
self.fc = nn.Linear(512,10)
def forward(self,x):
in_size = x.size(0)
x = self.mp(f.relu(self.conv1(x)))
x = self.rblock1(x)
x = self.mp(f.relu(self.conv2(x)))
x = self.rblock2(x)
x = x.view(in_size,-1)
x = self.fc(x)
return x
3.3 结果
依然是在MNIST数据集上测试，结果如下：
比GoogleNet准确率更高，到了99%
课后练习1：阅读并实现Identity Mappings in Deep Residual Networks
实现图左的Residual Block：
class ResidualBlock(nn.Module):
def __init__(self,channels):
super(ResidualBlock,self).__init__()
self.channels = channels #实现异步
self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
def forward(self,x):
y = f.relu(self.conv1(x))
y = self.conv2(y)
return f.relu((x+y)*0.5)
结果：
准确率不如上一个ResidualBlock
实现图右的Residual Block：
class ResidualBlock(nn.Module):
def __init__(self,channels):
super(ResidualBlock,self).__init__()
self.channels = channels #实现异步
self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1) #padding=1 保证图像输入输出前后的尺寸大小不变
self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
self.conv11 = nn.Conv2d(channels,channels,kernel_size=1) #实现1x1卷积
def forward(self,x):
y = f.relu(self.conv1(x))
y = self.conv2(y)
x = self.conv11(x)
return f.relu(x+y)
结果：
比左图ResidualBlock准确率更好，但是震荡比较多。
课后练习2：阅读和实现 Densely Connected Convolutional Networks（DenseNet）
https://www.codeleading.com/article/89321102194/
from __future__ import print_function
import torch
import time
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
from torch import optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.transforms import ToPILImage
show=ToPILImage()
import numpy as np
import matplotlib.pyplot as plt
batchSize=32
##load data
# transform = transforms.Compose([transforms.Resize(96),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# transform = transforms.Compose([transforms.Resize(96),transforms.ToTensor(),transforms.Lambda(lambda x: x.repeat(3,1,1)),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
transform = transforms.Compose([
transforms.Resize(96),
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True, num_workers=0)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False, num_workers=0)
def imshow(img):
img = img / 2 + 0.5
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
####network
class conv_blk(nn.Module):
def __init__(self,in_channel,num_channel):
super(conv_blk, self).__init__()
self.blk=nn.Sequential(nn.BatchNorm2d(in_channel,eps=1e-3),
nn.ReLU(),
nn.Conv2d(in_channels=in_channel,out_channels=num_channel,kernel_size=3,padding=1))
def forward(self, x):
return self.blk(x)
class DenseBlock(nn.Module):
def __init__(self,in_channel,num_convs,num_channels):
super(DenseBlock,self).__init__()
layers=[]
for i in range(num_convs):
layers+=[conv_blk(in_channel,num_channels)]
in_channel=in_channel+num_channels
self.net=nn.Sequential(*layers)
def forward(self,x):
for blk in self.net:
y=blk(x)
x=torch.cat((x,y),dim=1)
return x
def transition_blk(in_channel,num_channels):
blk=nn.Sequential(nn.BatchNorm2d(in_channel,eps=1e-3),
nn.ReLU(),
nn.Conv2d(in_channels=in_channel,out_channels=num_channels,kernel_size=1),
nn.AvgPool2d(kernel_size=2,stride=2))
return blk
class DenseNet(nn.Module):
def __init__(self,in_channel,num_classes):
super(DenseNet,self).__init__()
self.block1=nn.Sequential(nn.Conv2d(in_channels=in_channel,out_channels=64,kernel_size=7,stride=2,padding=3),
nn.BatchNorm2d(64,eps=1e-3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3,stride=2,padding=1))
num_channels, growth_rate = 64, 32 # num_channels：当前的通道数。
num_convs_in_dense_blocks = [4, 4, 4, 4]
layers=[]
for i ,num_convs in enumerate(num_convs_in_dense_blocks):
layers+=[DenseBlock(num_channels,num_convs,growth_rate)]
num_channels+=num_convs*growth_rate
if i!=len(num_convs_in_dense_blocks)-1:
layers+=[transition_blk(num_channels,num_channels//2)]
num_channels=num_channels//2
layers+=[nn.BatchNorm2d(num_channels),nn.ReLU(),nn.AvgPool2d(kernel_size=3)]
self.block2=nn.Sequential(*layers)
self.dense=nn.Linear(248,10)
def forward(self,x):
y=self.block1(x)
y=self.block2(y)
y=y.view(-1,248)
y=self.dense(y)
return y
net=DenseNet(1,10).cuda()
print (net)
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.1,momentum=0.9)
#train
print ("training begin")
for epoch in range(1):
start = time.time()
running_loss=0
for i,data in enumerate(trainloader,0):
# print (inputs,labels)
image,label=data
image=image.cuda()
label=label.cuda()
image=Variable(image)
label=Variable(label)
# imshow(torchvision.utils.make_grid(image))
# plt.show()
# print (label)
optimizer.zero_grad()
outputs=net(image)
# print (outputs)
loss=criterion(outputs,label)
loss.backward()
optimizer.step()
running_loss+=loss.data
if i%100==99:
end=time.time()
print ('[epoch %d,imgs %5d] loss: %.7f time: %0.3f s'%(epoch+1,(i+1)*batchSize,running_loss/100,(end-start)))
start=time.time()
running_loss=0
print ("finish training")
#test
net.eval()
correct=0
total=0
for data in testloader:
images,labels=data
images=images.cuda()
labels=labels.cuda()
outputs=net(Variable(images))
_,predicted=torch.max(outputs,1)
total+=labels.size(0)
correct+=(predicted==labels).sum()
print('Accuracy of the network on the %d test images: %d %%' % (total , 100 * correct / total))
学习资料
https://blog.csdn.net/lizhuangabby/article/details/125837409
系列文章索引
教程指路：【《PyTorch深度学习实践》完结合集】 https://www.bilibili.com/video/BV1Y7411d7Ys?share_source=copy_web&vd_source=3d4224b4fa4af57813fe954f52f8fbe7
Be First to Comment