Blanco puta plataforma Yu Bo, o para agradecer aproximadamente, jugando la publicidad de onda.
Principalmente notas de estudio, resolución de problemas pueden ser ignorados en este blog, a fin de no perder el tiempo y el esfuerzo
red neuronal de convolución profundidad
Ventajas y desventajas:
LeNet: rendimiento en grandes conjuntos de datos no hacen más real significado de la cara.
1. La red neuronal complejidad computacional.
2. START pero profunda investigación ampliada cantidad de parámetros de inicialización y viene muy bien algoritmos de optimización convexa y muchas otras áreas.
Máquina de extracción de características de aprendizaje: la función de extracción de características definidas manualmente
la red neural de extracción de características: datos multinivel caracterizados obtenidos por aprendizaje, y la tabla muestran conceptos progresivamente más abstractos o patrones.
Que limita el desarrollo de las redes neuronales: datos, hardware
AlexNet
Por primera vez, demostró que el aprendizaje puede ir más allá de las características del reloj cuenta con ⼯ diseño de modo ⼀ antes de romper movimiento como la investigación de visión por ordenador.
En la que:
1.8 capa convertida, cuya capa 5 y una capa oculta capa convolución 2 completamente conectado, y una capa de salida conectados completamente.
2. La función de activación sigmoide en una función de activación RELU más simple.
3. Dropout complejidad del modelo para el control de toda la capa de conexión.
4. Los datos de entrada mejoradas, tales como flipping, recorte y cambio de color, por lo tanto ampliar aún más el conjunto de datos para aliviar el exceso de montaje.
import time
import torch
from torch import nn, optim
import torchvision
import numpy as np
import sys
sys.path.append("/home/kesci/input/")
import d2lzh1981 as d2l
import os
import torch.nn.functional as F
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class AlexNet(nn.Module):
def __init__(self):
super(AlexNet, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
nn.ReLU(),
nn.MaxPool2d(3, 2), # kernel_size, stride
# 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
nn.Conv2d(96, 256, 5, 1, 2),
nn.ReLU(),
nn.MaxPool2d(3, 2),
# 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
# 前两个卷积层后不使用池化层来减小输入的高和宽
nn.Conv2d(256, 384, 3, 1, 1),
nn.ReLU(),
nn.Conv2d(384, 384, 3, 1, 1),
nn.ReLU(),
nn.Conv2d(384, 256, 3, 1, 1),
nn.ReLU(),
nn.MaxPool2d(3, 2)
)
# 这里全连接层的输出个数比LeNet中的大数倍。使用丢弃层来缓解过拟合
self.fc = nn.Sequential(
nn.Linear(256*5*5, 4096),
nn.ReLU(),
nn.Dropout(0.5),
#由于使用CPU镜像，精简网络，若为GPU镜像可添加该层
#nn.Linear(4096, 4096),
#nn.ReLU(),
#nn.Dropout(0.5),
# 输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
nn.Linear(4096, 10),
)
def forward(self, img):
feature = self.conv(img)
output = self.fc(feature.view(img.shape[0], -1))
return output
estructura de red de salida
net = AlexNet()
print(net)
AlexNet (
(conv): secuencial (
(0): Conv2d (1, 96, kernel_size = (11, 11), paso = (4, 4))
(1): relu ()
(2): MaxPool2d (kernel_size = 3 , paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
(3): Conv2d (96, 256, kernel_size = (5, 5), paso = (1, 1), relleno = (2, 2) )
(4): relu ()
(5): MaxPool2d (kernel_size = 3, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
(6): Conv2d (256, 384, kernel_size = (3, 3 ), paso = (1, 1), relleno = (1, 1))
(7): relu ()
(8): Conv2d (384, 384, kernel_size = (3, 3), paso = (1, 1) , relleno = (1, 1))
(9): relu ()
(10): Conv2d (384, 256, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(11): relu ()
(12): MaxPool2d (kernel_size = 3, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
)
(fc): Secuencial (
(0): lineales (in_features = 6,400, out_features = 4096, el sesgo = True )
(1): relu ()
(2): de deserción (p = 0,5, inplace = False)
(3): lineal (in_features = 4,096, out_features = 10, el sesgo = True)
)
)
conjunto de datos de carga
# 本函数已保存在d2lzh_pytorch包中方便以后使用
def load_data_fashion_mnist(batch_size, resize=None, root='/home/kesci/input/FashionMNIST2065'):
"""Download the fashion mnist dataset and then load into memory."""
trans = []
if resize:
trans.append(torchvision.transforms.Resize(size=resize))
trans.append(torchvision.transforms.ToTensor())
transform = torchvision.transforms.Compose(trans)
mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=2)
test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=2)
return train_iter, test_iter
#batchsize=128
batch_size = 16
# 如出现“out of memory”的报错信息，可减小batch_size或resize
train_iter, test_iter = load_data_fashion_mnist(batch_size,224)
for X, Y in train_iter:
print('X =', X.shape,
'\nY =', Y.type(torch.int32))
break
输出X = torch.Size ([16, 1, 224, 224])
Y = tensor ([5, 2, 9, 3, 1, 8, 3, 3, 2, 6, 1, 6, 2, 4, 4, 8], dtype = torch.int32)
formación
lr, num_epochs = 0.001, 3 # 学习率，跌代周期
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)
elemento de red duplicados (VGG)
Características VGG Red
VGG: al hacer repetidamente un bloque de base sencilla construyó Uso modelo de profundidad.
Block: el mismo número de llenado 1, la forma de la ventana de 3 × 3 capa de convolución, conectado a un paso de 2, la forma de la célula máximo de la capa de la ventana es 2 × 2.
capa de Convolución permanece altura de entrada sin cambios y el ancho, y la capa celular es su medio.
VGG aplicación sencilla 11
def vgg_block(num_convs, in_channels, out_channels): #卷积层个数，输入通道数，输出通道数
blk = []
for i in range(num_convs):
if i == 0:
blk.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
else:
blk.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))
blk.append(nn.ReLU())
blk.append(nn.MaxPool2d(kernel_size=2, stride=2)) # 这里会使宽高减半
return nn.Sequential(*blk)
conv_arch = ((1, 1, 64), (1, 64, 128), (2, 128, 256), (2, 256, 512), (2, 512, 512))
# 经过5个vgg_block, 宽高会减半5次, 变成 224/32 = 7
fc_features = 512 * 7 * 7 # c * w * h
fc_hidden_units = 4096 # 任意
def vgg(conv_arch, fc_features, fc_hidden_units=4096):
net = nn.Sequential()
# 卷积层部分
for i, (num_convs, in_channels, out_channels) in enumerate(conv_arch):
# 每经过一个vgg_block都会使宽高减半
net.add_module("vgg_block_" + str(i+1), vgg_block(num_convs, in_channels, out_channels))
# 全连接层部分
net.add_module("fc", nn.Sequential(d2l.FlattenLayer(),
nn.Linear(fc_features, fc_hidden_units),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(fc_hidden_units, fc_hidden_units),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(fc_hidden_units, 10)
))
return net
net = vgg(conv_arch, fc_features, fc_hidden_units)
X = torch.rand(1, 1, 224, 224)
# named_children获取一级子模块及其名字(named_modules会返回所有子模块,包括子模块的子模块)
for name, blk in net.named_children():
X = blk(X)
print(name, 'output shape: ', X.shape)
de forma de salida vgg_block_1: torch.Size ([1, 64, 112, 112])
vgg_block_2 forma de salida: torch.Size ([1, 128, 56, 56])
de forma de salida vgg_block_3: torch.Size ([1, 256, 28 , 28])
vgg_block_4 forma de salida: torch.Size ([1, 512, 14, 14])
vgg_block_5 forma de salida: torch.Size ([1, 512, 7, 7])
fc forma de salida: torch.Size ([1 , 10])
ratio = 8
small_conv_arch = [(1, 1, 64//ratio), (1, 64//ratio, 128//ratio), (2, 128//ratio, 256//ratio),
(2, 256//ratio, 512//ratio), (2, 512//ratio, 512//ratio)]
net = vgg(small_conv_arch, fc_features // ratio, fc_hidden_units // ratio)
print(net)
输出网络结构
secuencial (
(vgg_block_1): secuencial (
(0): Conv2d (1, 8, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(1): relu ()
(2): MaxPool2d (kernel_size = 2, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
)
(vgg_block_2): secuencial (
(0): Conv2d (8, 16, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(1): relu ()
(2): MaxPool2d (kernel_size = 2, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
)
(vgg_block_3): secuencial (
(0): Conv2d (16, 32, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(1): relu ()
(2): Conv2d (32, 32, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(3): relu ()
(4): MaxPool2d (kernel_size = 2, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
)
(vgg_block_4): secuencial (
(0): Conv2d (32, 64, kernel_size = (3, 3) , paso = (1, 1), relleno = (1, 1))
(1): relu ()
(2): Conv2d (64, 64, kernel_size = (3, 3), paso = (1, 1), acolchado = (1, 1))
(3): relu ()
(4): MaxPool2d (kernel_size = 2, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = False)
)
(vgg_block_5): secuencial (
(0 ): Conv2d (64, 64, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(1): relu ()
(2): Conv2d (64, 64, kernel_size = (3, 3), paso = (1, 1), relleno = (1, 1))
(3): relu ()
(4): MaxPool2d (kernel_size = 2, paso = 2, el relleno = 0, la dilatación = 1, ceil_mode = FALSE)
)
(fc): secuencial (
(0): FlattenLayer ()
(1): lineales (in_features = 3,136, out_features = 512, el sesgo = Verdadero)
(2): relu ()
(3): deserción (p = 0,5, inplace = Falso)
(4): lineal (in_features = 512, out_features = 512, el sesgo = Verdadero)
(5): relu ()
(6): deserción (p = 0,5, inplace = False)
(7): lineales (in_features = 512 , out_features = 10, el sesgo = true)
)
)
formación
batchsize=16
#batch_size = 64
# 如出现“out of memory”的报错信息，可减小batch_size或resize
# train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)
La red NiN
LeNet, AlexNet y VGG: espacio de características de un módulo compuesto de una primera capa convolucional está suficientemente extrajo, a continuación, el módulo está conectado a través de un resultado de clasificación capa completa es la salida.
NiN: capas de convolución y una pluralidad de series "completamente conectado" pequeñas redes abiertas construidos ⼀ capa hecha de una profunda redes abiertas.
Utilizando el número de canales de salida igual al número de bloques de etiqueta de categoría Nin, a continuación, utilizar la piscina media global de todos los elementos de la capa de promediado en cada canal para directamente Uso clasificación.
1 × 1 nucleación convolución
1. La clasificación de canales: Mediante el control del número de canales alcanza un núcleo de convolución de zoom.
2. Aumento lineal. 1 × 1 convolución proceso equivalente al proceso de cálculo de convolución completamente conectado capas, y también la adición de una función de activación no lineal, aumentando de este modo la red no lineal.
3. Cálculo menos parámetros
def nin_block(in_channels, out_channels, kernel_size, stride, padding):
blk = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
nn.ReLU(),
nn.Conv2d(out_channels, out_channels, kernel_size=1),
nn.ReLU(),
nn.Conv2d(out_channels, out_channels, kernel_size=1),
nn.ReLU())
return blk
# 已保存在d2lzh_pytorch
class GlobalAvgPool2d(nn.Module):
# 全局平均池化层可通过将池化窗口形状设置成输入的高和宽实现
def __init__(self):
super(GlobalAvgPool2d, self).__init__()
def forward(self, x):
return F.avg_pool2d(x, kernel_size=x.size()[2:])
net = nn.Sequential(
nin_block(1, 96, kernel_size=11, stride=4, padding=0),
nn.MaxPool2d(kernel_size=3, stride=2),
nin_block(96, 256, kernel_size=5, stride=1, padding=2),
nn.MaxPool2d(kernel_size=3, stride=2),
nin_block(256, 384, kernel_size=3, stride=1, padding=1),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Dropout(0.5),
# 标签类别数是10
nin_block(384, 10, kernel_size=3, stride=1, padding=1),
GlobalAvgPool2d(),
# 将四维的输出转成二维的输出，其形状为(批量大小, 10)
d2l.FlattenLayer())
X = torch.rand(1, 1, 224, 224)
for name, blk in net.named_children():
X = blk(X)
print(name, 'output shape: ', X.shape)
输出参数尺寸
0 de salida forma: torch.Size ([1, 96, 54, 54])
forma 1 de salida: torch.Size ([1, 96, 26, 26])
forma 2 de salida: torch.Size ([1, 256, 26, 26])
3 de salida forma: torch.Size ([1, 256, 12, 12])
4 de forma de salida: torch.Size ([1, 384, 12, 12])
5 de forma de salida: torch.Size ([1, 384, 5, 5])
6 de forma de salida: torch.Size ([1, 384, 5, 5])
7 de forma de salida: torch.Size ([1, 10, 5, 5])
8 de salida de forma : torch.Size ([1, 10, 1, 1])
forma 9 de salida: torch.Size ([1, 10])
训练
batch_size = 128
# 如出现“out of memory”的报错信息，可减小batch_size或resize
#train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
lr, num_epochs = 0.002, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)
El uso repetido de la capa NiN convolución y una capa de unión en lugar de bloques enteros de 1 × 1 capa NiN compuestas de convolución para construir redes abiertas profundas.
NiN eliminado fácilmente hacer que la capa de salida a través del accesorio conexión completa, sino más bien para sustituirlo por el número de canales de salida igual al número de bloques y una categoría etiqueta global NiN capa de células de la media.
Las redes abiertas a una amplia gama de diseño de los nervios después de convolución Nin ideas de diseño anteriores han influido en el ⾯.
GooLeNet
1. Origen de los bloques de base.
2.Inception ⼀ un bloque que corresponde a una línea con un 4 redes Submenú abiertas. Y ⾏ para extraer capa de información y una capa de convolución es más grandes piscinas de diferentes formas de ventana, y utilizar un 1 × 1 capa convolucional reduce el número de canales para reducir la complejidad del modelo.
3. parámetro Ultra Custom es el número de canal de salida de cada capa, con el fin de controlar la complejidad de nuestro modelo.
class Inception(nn.Module):
# c1 - c4为每条线路里的层的输出通道数
def __init__(self, in_c, c1, c2, c3, c4):
super(Inception, self).__init__()
# 线路1，单1 x 1卷积层
self.p1_1 = nn.Conv2d(in_c, c1, kernel_size=1)
# 线路2，1 x 1卷积层后接3 x 3卷积层
self.p2_1 = nn.Conv2d(in_c, c2[0], kernel_size=1)
self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
# 线路3，1 x 1卷积层后接5 x 5卷积层
self.p3_1 = nn.Conv2d(in_c, c3[0], kernel_size=1)
self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
# 线路4，3 x 3最大池化层后接1 x 1卷积层
self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
self.p4_2 = nn.Conv2d(in_c, c4, kernel_size=1)
def forward(self, x):
p1 = F.relu(self.p1_1(x))
p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
p4 = F.relu(self.p4_2(self.p4_1(x)))
return torch.cat((p1, p2, p3, p4), dim=1) # 在通道维上连结输出
modelo GooLeNet
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),
nn.Conv2d(64, 192, kernel_size=3, padding=1),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
Inception(256, 128, (128, 192), (32, 96), 64),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
Inception(512, 160, (112, 224), (24, 64), 64),
Inception(512, 128, (128, 256), (24, 64), 64),
Inception(512, 112, (144, 288), (32, 64), 64),
Inception(528, 256, (160, 320), (32, 128), 128),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
Inception(832, 384, (192, 384), (48, 128), 128),
d2l.GlobalAvgPool2d())
net = nn.Sequential(b1, b2, b3, b4, b5,
d2l.FlattenLayer(), nn.Linear(1024, 10))
net = nn.Sequential(b1, b2, b3, b4, b5, d2l.FlattenLayer(), nn.Linear(1024, 10))
X = torch.rand(1, 1, 96, 96)
for blk in net.children():
X = blk(X)
print('output shape: ', X.shape)
#batchsize=128
batch_size = 16
# 如出现“out of memory”的报错信息，可减小batch_size或resize
#train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)
