深度学习（七）一些神经网络的构架
2020-08-01 本文已影响0人
升不上三段的大鱼
- 多层感知器
前馈神经网络，也可以叫多层感知器（multi-layer perceptron, MLP），是由多个感知器组成的神经网络。与单个感知器不同的是，MLP能够学习到非线性的特征，因此在回归和分类里都有很多应用。
MLP一般由一层输入层，几层隐藏层和一个输出层，就像下图。
A fully connected MLP on three inputs with two hidden layers, each with four perceptrons
隐藏层和输出层里都是有激活函数的，每一层的神经元与同一层的其他神经元没有关联，与上一层的所有神经元都有联系（全连接）。
关于前馈神经网络，深度学习笔记（1）--前馈神经网络。
接下来利用pytorch实现上面图里的神经网络。
class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNet, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, num_classes)
def forward(self, x):
out = self.fc1(x)
out = self.relu(out)
out = self.fc2(out)
return out
model = NeuralNet(input_size=3,
- 卷积神经网络
卷积神经网络适合用于图像处理，卷积操作可以提取出图片的特征。一般的卷积神经网络包括卷积层、池化层和全连接层。卷积层提取信息，池化层降维，全连接层输出结果。卷积层和池化层会多次使用，以达到提出特征的目的，比如LeNet的结构：
LeNet
pytorch 实现一个简单的卷积神经网络：
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 1 input image channel, 6 output channels, 3x3 square convolution
# kernel
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.Conv2d(6, 16, 3)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 6 * 6, 120) # 6*6 from image dimension
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# Max pooling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:] # all dimensions except the batch dimension
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
接下来就是一些经典的CNN模型
- LeNet
结构就是上面那张图，1998年提出来的，包括两个卷积层+池化层，一个flatten层，两个全连接层和一个softmax的分类器。
特点：
- 使用卷积提取空间特征
- 使用average pooling做采样
- 使用tanh作为非线性的激活函数
- S2和C3之间的连接
LeNet 提出的卷积-池化-非线性激活函数的顺序，为以后的许多结构提供了基础。
- AlexNet
AlexNet
特点：
- AlexNet中用到了ReLU，虽然在现在大家都用ReLU，以至于这一条显得平平无奇。
- AlexNet还使用了两个GPU并行训练，也就是上面结构图里的上下两层，每个GPU只用一半的神经元，并且在某些层进行连接。这样做能让训练相对快一点，并且降低了错误率。
- 使用了重叠池化，stride=2，size=3，这个操作也能减少错误率。
- dropout，减少过拟合。神仙一样的方法，以0.5的概率把隐藏层神经元的输出设为0，被设为0的神经元在反向的时候也没有梯度。作者在前两个全连接层上使用了dropout。
- mini-batch SGD+momentum （0.9 ）+ weight decay（0.0005）。具体的参数迭代规则是这样的：
update rule for weight
pytorch 可以直接调用 torchvision.models.alexnet()， 在这里放上具体的结构实现：
class AlexNet(nn.Module):
def __init__(self, num_classes=1000):
super(AlexNet, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(64, 192, kernel_size=5, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(192, 384, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(384, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
)
self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, num_classes),
)
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.classifier(x)
return x
-
Network In Network
Network in network结构，包括三个mlpcov层和一个GAP层
特点：
- 1x1卷积核，提供非线性，减少参数
- 全局平均池化，避免过拟合
CNN中的卷积操作可以看作是一种广义的线性操作，对于高度非线性的特征，CNN可能需要许多滤波器来进行特征提取，从而导致模型的参数过多。
Network in network提出使用多层感知器作为通用函数逼近器来对局部的特征进行提取。使用多层感知器的原因是，首先，多层感知器与使用反向传播训练的卷积神经网络结构兼容。 其次，多层感知器本身可以是一个深层模型，这符合特征复用的思想。
使用多个级联的1x1的卷积核对特征图做卷积，可以实现特征图的非线性组合，同时使用1x1卷积核还可以减少或者增加通道数，实现降维或者升维，减少参数。
NIN的另一个进步之处在于使用了全局平均池化（Global Average Pooling, GAP）取代全连接层作为最后一层，具体做法是取每个特征图的平均值，然后将所得的向量直接输入softmax层实现分类，这样做的优点是，在全局平均池中没有要优化的参数，减小了参数规模，避免了过拟合。此外，全局平均池汇总了空间信息，因此对输入的空间转换更加健壮。
class NIN(nn.Module):
def __init__(self, num_classes=1000):
super(NIN, self).__init__()
self.num_classes = num_classes
self.features = nn.Sequential(
nn.Conv2d(3, 192, 5, padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(192, 160, 1),
nn.ReLU(inplace=True),
nn.Conv2d(160, 96, 1),
nn.ReLU(inplace=True),
nn.MaxPool2d(3, stride=2, ceil_mode=True),
nn.Dropout(inplace=True),
nn.Conv2d(96, 192, 5, padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(192, 192, 1),
nn.ReLU(inplace=True),
nn.Conv2d(192, 192, 1),
nn.ReLU(inplace=True),
nn.AvgPool2d(3, stride=2, ceil_mode=True),
nn.Dropout(inplace=True),
nn.Conv2d(192, 192, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(192, 192, 1),
nn.ReLU(inplace=True),
nn.Conv2d(192, self.num_classes, 1),
nn.ReLU(inplace=True),
nn.AvgPool2d(8, stride=1)
)
self._initialize_weights()
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), self.num_classes)
return x
def _initialize_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight.data.normal_(0, 0.05)
if m.bias is not None:
m.bias.data.zero_()
Network in Network
Network in Network代码
深度学习基础模型NIN(Network in Network)+Pytorch
- VGG
VGG于2014年由牛津大学Visual Geometry Group组提出的，在AlexNet的基础上加深了网络。
特点：
- 使用多个较小的卷积核（3x3）组合以获得更大的感受野，但是所需要的参数更少
- 比较难训练，常被用作预训练
VGG系列的网络结构和参数设置
下面是pytorch里vgg11的代码，可以看出来结构与AlexNet很相似，不过层数更多：
class VGG(nn.Module):
def __init__(self, features, num_classes=1000, init_weights=True):
super(VGG, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn.ReLU(inplace=True)
nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn.ReLU(inplace=True)
nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
nn. Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn. ReLU(inplace=True)
nn. Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn. ReLU(inplace=True)
nn. MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn. ReLU(inplace=True)
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn. ReLU(inplace=True)
nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn. ReLU(inplace=True)
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
nn.ReLU(inplace=True)
nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
self.classifier = nn.Sequential(
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(4096, num_classes),
)
if init_weights:
self._initialize_weights()
def forward(self, x):
x = self.features(x)
x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.classifier(x)
return x
- GoogleNet
（Inception-v1）
- bottleneck layer
- ResNet
随着网络结构的加深，人们发现深层的网络的训练和测试误差比浅层的网络还要大，并且这一现象并不是由过拟合造成的。原因就在于在深层的网络中随着层数的加深，特征和梯度传递可能会发生偏移。
Residual Block
9.MobileNet
- EfficientNet
