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
se centra en tres áreas
modelo Lenet se describe en
estructuras de red Lenet
utilizar un reconocimiento de imagen Lenet conjunto de datos -fashion-mnist
modelo LeNet
LeNet capa de bloque de convolución dos partes y el bloque de capa totalmente conectado. A continuación se describen estos dos módulos.
El siguiente modelo de estructura
que comprende: una capa de entrada, una convolución de dos capas, dos capas oculta completamente conectado, y una capa de salida completamente conectado
Capa de bloque de convolución en la unidad de capa de células de acceso medio de capa de convolución básica: Convolución capa sirve para identificar la imagen en los patrones espaciales, tales como líneas y objeto local, la capa de células promedio después de capa se utiliza para reducir la convolución la sensibilidad de la localización.
Capa de bloque de convolución de dos de tales unidades básicas se apilan repetidamente configuración. Capa de bloque de convolución, la convolución en cada capa utiliza una ventana de 5 × 5, y el uso de la función de activación sigmoide en la salida. Los primeros canales de salida de capa convolucional es 6, una segunda capa convolucional se aumenta a 16 el número de canales de salida.
bloque de capa totalmente conectado contiene 3 capas totalmente conectadas. El número de salidas del mismo, respectivamente, 120,84 y 10, donde 10 es el número de clases de salida.
Ahora nos damos cuenta de modelo LeNet por clase secuencial.
#import
import sys
sys.path.append("/home/kesci/input")
import d2lzh1981 as d2l
import torch
import torch.nn as nn
import torch.optim as optim
import time
#net
class Flatten(torch.nn.Module): #展平操作
def forward(self, x):
return x.view(x.shape[0], -1)
class Reshape(torch.nn.Module): #将图像大小重定型
def forward(self, x):
return x.view(-1,1,28,28) #(B x C x H x W)
net = torch.nn.Sequential( #Lelet
Reshape(),
nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2), #b*1*28*28 =>b*6*28*28
nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2, stride=2), #b*6*28*28 =>b*6*14*14
nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5), #b*6*14*14 =>b*16*10*10
nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2, stride=2), #b*16*10*10 => b*16*5*5
Flatten(), #b*16*5*5 => b*400
nn.Linear(in_features=16*5*5, out_features=120),
nn.Sigmoid(),
nn.Linear(120, 84),
nn.Sigmoid(),
nn.Linear(84, 10)
)
A continuación, se construye un solo canal de datos son la altura y anchura de la muestra 28, y la capa delantera por capa a la computación en la salida de la forma de cada capa.
print
X = torch.randn(size=(1,1,28,28), dtype = torch.float32)
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape: \t',X.shape)
每层的尺寸输出
forma de salida Reshape: torch.Size ([1, 1, 28, 28])
Conv2d forma de salida: torch.Size ([1, 6, 28, 28])
sigmoide forma de salida: torch.Size ([ 1, 6, 28, 28])
AvgPool2d forma de salida: torch.Size ([1, 6, 14, 14])
Conv2d forma de salida: torch.Size ([1, 16, 10, 10])
de forma de salida sigmoide: antorcha .size ([1, 16, 10, 10])
AvgPool2d forma de salida: torch.Size ([1, 16, 5, 5])
Aplanar forma de salida: torch.Size ([1, 400])
Linear forma de salida: antorcha .size ([1, 120])
de forma de salida sigmoide: torch.Size ([1, 120])
Linear forma de salida: torch.Size ([1, 84])
sigmoide forma de salida: torch.Size ([1, 84] )
Linear forma de salida: torch.Size ([1, 10])
Se puede observar en la altura del bloque de convolución capa de entrada y la anchura disminuye capa por capa. El uso de la altura de la capa convolucional y la anchura son 5 convolución kernel, reduciendo de este modo la altura y anchura, respectivamente 4, mientras que la altura de la piscina y la anchura de la capa se reducen a la mitad, pero el número de canales de 1 a 16. Capa está totalmente conectado a reducir el número de salida de capa hasta que se convierte el número de imagen de las categorías 10.
El acceso a los datos y modelo de tren
Lograr modelo LeNet. Moda-MNIST que todavía utilizan como un conjunto de datos de entrenamiento.
# 数据
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(
batch_size=batch_size, root='/home/kesci/input/FashionMNIST2065')
print(len(train_iter))
La adición de una parte extra para visualizar los datos de imagen
#数据展示
import matplotlib.pyplot as plt
def show_fashion_mnist(images, labels):
d2l.use_svg_display()
# 这里的_表示我们忽略（不使用）的变量
_, figs = plt.subplots(1, len(images), figsize=(12, 12))
for f, img, lbl in zip(figs, images, labels):
f.imshow(img.view((28, 28)).numpy())
f.set_title(lbl)
f.axes.get_xaxis().set_visible(False)
f.axes.get_yaxis().set_visible(False)
plt.show()
for Xdata,ylabel in train_iter:
break
X, y = [], []
for i in range(10):
print(Xdata[i].shape,ylabel[i].numpy())
X.append(Xdata[i]) # 将第i个feature加到X中
y.append(ylabel[i].numpy()) # 将第i个label加到y中
show_fashion_mnist(X, y)
torch.Size ([. 1, 28, 28]). 3
torch.Size ([. 1, 28, 28]). 8
torch.Size ([. 1, 28, 28]). 1
torch.Size ([. 1, 28, 28] ). 4
torch.Size ([. 1, 28, 28]) 0
torch.Size ([. 1, 28, 28]) 0
torch.Size ([. 1, 28, 28]). 4
torch.Size (. [1, 28, 28]). 9
torch.Size ([. 1, 28, 28]). 4
torch.Size ([. 1, 28, 28]). 7
como la red neuronal de convolución de cálculo complejo confidencial de perceptrón de múltiples capas, usando una aceleración GPU calculado recomienda . Comprobar para ver si podemos utilizar la GPU, si uso exitoso CUDA: 0, de lo contrario seguir utilizando la CPU.
# This function has been saved in the d2l package for future use
#use GPU
def try_gpu():
"""If GPU is available, return torch.device as cuda:0; else return torch.device as cpu."""
if torch.cuda.is_available():
device = torch.device('cuda:0')
else:
device = torch.device('cpu')
return device
device = try_gpu()
device
Lograr evaluate_accuracy función, que se utiliza para calcular conjunto de datos de modelo de red a la exactitud de data_iter.
#计算准确率
'''
(1). net.train()
启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为True
(2). net.eval()
不启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为False
'''
def evaluate_accuracy(data_iter, net,device=torch.device('cpu')):
"""Evaluate accuracy of a model on the given data set."""
acc_sum,n = torch.tensor([0],dtype=torch.float32,device=device),0
for X,y in data_iter:
# If device is the GPU, copy the data to the GPU.
X,y = X.to(device),y.to(device)
net.eval()
with torch.no_grad():
y = y.long()
acc_sum += torch.sum((torch.argmax(net(X), dim=1) == y)) #[[0.2 ,0.4 ,0.5 ,0.6 ,0.8] ,[ 0.1,0.2 ,0.4 ,0.3 ,0.1]] => [ 4 , 2 ]
n += y.shape[0]
return acc_sum.item()/n
Se define la función train_ch5, utilizado para entrenar el modelo.
#训练函数
def train_ch5(net, train_iter, test_iter,criterion, num_epochs, batch_size, device,lr=None):
"""Train and evaluate a model with CPU or GPU."""
print('training on', device)
net.to(device)
optimizer = optim.SGD(net.parameters(), lr=lr)
for epoch in range(num_epochs):
train_l_sum = torch.tensor([0.0],dtype=torch.float32,device=device)
train_acc_sum = torch.tensor([0.0],dtype=torch.float32,device=device)
n, start = 0, time.time()
for X, y in train_iter:
net.train()
optimizer.zero_grad()
X,y = X.to(device),y.to(device)
y_hat = net(X)
loss = criterion(y_hat, y)
loss.backward()
optimizer.step()
with torch.no_grad():
y = y.long()
train_l_sum += loss.float()
train_acc_sum += (torch.sum((torch.argmax(y_hat, dim=1) == y))).float()
n += y.shape[0]
test_acc = evaluate_accuracy(test_iter, net,device)
print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, '
'time %.1f sec'
% (epoch + 1, train_l_sum/n, train_acc_sum/n, test_acc,
time.time() - start))
Vamos a volver a inicializar los parámetros del modelo correspondiente al dispositivo de dispositivo (CPU o cuda: 0) anterior, y utilizando la inicialización aleatorio Xavier. funciones de pérdida y algoritmos de entrenamiento siguen utilizando la función de pérdida de entropía cruzada y pequeñas cantidades de descenso de gradiente estocástico.
# 训练
lr, num_epochs = 0.9, 10
def init_weights(m):
if type(m) == nn.Linear or type(m) == nn.Conv2d:
torch.nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)
net = net.to(device)
criterion = nn.CrossEntropyLoss() #交叉熵描述了两个概率分布之间的距离，交叉熵越小说明两者之间越接近
train_ch5(net, train_iter, test_iter, criterion,num_epochs, batch_size,device, lr)
# test
for testdata,testlabe in test_iter:
testdata,testlabe = testdata.to(device),testlabe.to(device)
break
print(testdata.shape,testlabe.shape)
net.eval()
y_pre = net(testdata)
print(torch.argmax(y_pre,dim=1)[:10])
print(testlabe[:10])
resumen:
red neural convolucional es una red que contiene una capa de convolución. LeNet las capas alternantes y la capa de contacto máxima piscina convolución capas totalmente conectadas para la clasificación de imágenes.
