Red neuronal convolucional profunda (ALEXNET)

Parte de las notas de estudio de "Practica Pytorch de aprendizaje profundo" es solo para tu propia revisión.

Red neuronal convolucional profunda (ALEXNET)

Casi 20 años después de la propuesta de LeNet, las redes neuronales han sido superadas por otros métodos de aprendizaje automático, como las máquinas vectoriales de soporte. Aunque LeNet puede lograr buenos resultados en los primeros conjuntos de datos pequeños, su rendimiento en conjuntos de datos reales más grandes no es tan bueno como se esperaba .

Por un lado, las redes neuronales son computacionalmente complejas . Aunque hubo algún hardware de aceleración para redes neuronales en la década de 1990 del siglo XX, no fueron tan populares como las GPU después. Por lo tanto, el entrenamiento de una red neuronal multicanal, multicapa y convolucional con grandes parámetros fue difícil de completar en el año. Por otro lado, cuando 年 los investigadores aún no son grandes 量 el estudio en profundidad de la inicialización de parámetros y los algoritmos de optimización no convexa y otros campos, el entrenamiento de redes neuronales complejas suele ser difícil.

La red neuronal puede clasificar directamente en función de los píxeles originales de la imagen. Este método llamado de extremo a extremo ahorra 了 muchos pasos intermedios. Sin embargo, durante mucho tiempo, lo que ha fluido son las características manuales diseñadas y producidas por los investigadores a través del trabajo y la sabiduría. El proceso principal de este tipo de investigación de clasificación de imágenes es:

  • 1. Obtenga el conjunto de datos de imágenes;
  • 2. Utilice las funciones de extracción de características existentes para generar características de imagen;
  • 3. Utilice modelos de aprendizaje automático para clasificar las características de las imágenes.

Lo que realmente importa en el proceso de visión por computadora son los datos y las características . En otras palabras, el uso de conjuntos de datos más limpios y características más efectivas tiene un mayor impacto en los resultados de clasificación de imágenes que la elección del modelo de aprendizaje automático. 

Representación de características de aprendizaje

En una cantidad considerable de tiempo, las características se extraen de los datos basándose en varias funciones diseñadas manualmente . De hecho, muchos investigadores continúan mejorando los resultados de la clasificación de imágenes al proponer nuevas funciones de extracción de características. Esto ha hecho una contribución importante al desarrollo de la visión por computadora.

Algunos investigadores no están de acuerdo. Creen que las características mismas también deben aprenderse . También creen que para representar entradas suficientemente complejas, las características mismas deben representarse jerárquicamente. Los investigadores que sostienen esta idea creen que las redes neuronales multicapa pueden ser capaces de aprender representaciones multinivel de datos y representar conceptos o patrones cada vez más abstractos nivel por nivel . Tome la clasificación de imágenes como ejemplo 例, un ejemplo de detección de bordes de objetos en una capa convolucional bidimensional. En una red neuronal multicapa, la representación de primer nivel de la imagen puede ser si hay bordes en una posición y longitud específicas, y la representación de segundo nivel puede combinar estos bordes en patrones interesantes, como patrones; En el tercer nivel de representación, quizás los patrones del nivel anterior se puedan fusionar aún más en patrones correspondientes a partes específicas del objeto. De esta manera, la representación continúa nivel por nivel, al final, el modelo puede completar fácilmente la tarea de clasificación en base a la representación del último nivel. Se debe enfatizar que la representación nivel por nivel de la entrada está determinada por los parámetros en el modelo multicapa, y todos estos parámetros se aprenden .

Aunque hay un grupo de investigadores persistentes que están constantemente estudiando e intentando aprender la representación jerárquica de los datos visuales, pero durante mucho tiempo, estas personas salvajes no han podido lograrlo. Hay muchos factores en esto que merecen nuestro análisis.

Falta el elemento uno: datos

Un modelo profundo que contiene muchas características requiere una gran cantidad de datos etiquetados para funcionar mejor que otros métodos clásicos. Limitado al almacenamiento limitado de las primeras computadoras y al presupuesto limitado de investigación en la década de 1990, la mayor parte de la investigación solo se basó en pequeños conjuntos de datos públicos. Esta situación mejoró con la ola de big data que surgió alrededor de 2010. En particular, el conjunto de datos de ImageNet nacido en 2009 年 contiene 1,000 tipos de objetos, cada uno con miles de imágenes. El conjunto de datos de ImageNet promueve simultáneamente la investigación de la visión por computadora y el aprendizaje automático en una nueva etapa, lo que hace que los métodos tradicionales anteriores ya no tengan ventajas.

Falta el elemento dos: hardware

El aprendizaje profundo requiere recursos informáticos muy elevados. La potencia informática del hardware inicial era limitada, lo que dificultaba el entrenamiento de redes neuronales más complejas. Sin embargo, la llegada de las GPU de uso general ha cambiado este patrón. Durante mucho tiempo, las GPU se han diseñado para el procesamiento de imágenes y los juegos de computadora , especialmente para la multiplicación de matrices y vectores para un alto rendimiento para servir transformaciones gráficas básicas. Afortunadamente, la expresión matemática es similar a la expresión de la capa convolucional en la red profunda. El concepto de GPU universal comenzó a surgir en 2001, y surgieron marcos de programación como OpenCL y CUDA . Esto hace que las GPU también sean utilizadas por la comunidad de aprendizaje automático alrededor de 2010 年.

ALEXNET

En 2012 , AlexNet se nace. El nombre de este modelo proviene del nombre del primer autor del artículo, Alex Krizhevsky [1]. AlexNet utiliza una red neuronal convolucional de 8 capas y ganó el Desafío de reconocimiento de imágenes ImageNet 2012 con una gran ventaja. Demuestra por primera vez que las características aprendidas pueden superar las características del diseño manual, rompiendo así el estado anterior de la investigación de la visión por computadora.

Los principios de diseño de AlexNet y LeNet son muy similares, pero también existen diferencias significativas.
Primero, en contraste con LeNet relativamente pequeño, AlexNet contiene 8 capas de transformación, incluidas 5 capas de convolución y 2 capas de capas ocultas completamente conectadas, y una capa de salida completamente conectada.

La forma de la ventana de convolución en la primera capa de AlexNet es 11 × 11. Debido a que la altura y el ancho de la mayoría de las imágenes en ImageNet son más de 10 veces más grandes que las de las imágenes MNIST, los objetos en las imágenes ImageNet ocupan más píxeles, por lo que se necesita una ventana de convolución más grande para capturar objetos . La forma de la ventana de convolución en la segunda capa se reduce a 5 × 5, y luego se usa 3 × 3. Además, después de la primera, segunda y quinta capas convolucionales, se utiliza la capa de agrupación más grande con una forma de ventana de 3 × 3 y una zancada de 2 . Además, el número de canales de convolución utilizados por AlexNet es decenas de veces mayor que el número de canales de convolución en LeNet.
Después de la última capa convolucional hay dos capas completamente conectadas con 4096 salidas. Estas dos enormes capas completamente conectadas aportan casi 1 GB de parámetros de modelo. Debido a las limitaciones de las primeras memorias de video , la primera AlexNet usó un diseño de flujo de datos dual para que una GPU solo necesita procesar la mitad del modelo. Afortunadamente, ha habido suficiente desarrollo en los últimos años, por lo que normalmente ya no necesitamos un diseño tan especial.

En segundo lugar, AlexNet cambió la función de activación sigmoidea a una función de activación ReLU más simple .

Por un lado, el cálculo de la función de activación de ReLU es más sencillo , si no tiene la operación de exponenciación en la función de activación sigmoidea.

Por otro lado, la función de activación de ReLU hace que el modelo se entrene más con diferentes métodos de inicialización de parámetros. Esto se debe a que cuando la salida de la función de activación sigmoidea está muy cerca de 0 o 1, el gradiente de estas regiones es casi 0, lo que evita que continúe la propagación hacia atrás. Nueva parte de los parámetros del modelo; y el gradiente de la función de activación ReLU en el intervalo positivo es siempre 1. . Por lo tanto, si los parámetros del modelo no se inicializan correctamente, la función sigmoidea puede obtener un gradiente de casi 0 en el intervalo positivo , lo que evita que el modelo se entrene de manera efectiva.

En tercer lugar, AlexNet utiliza el método de descarte para controlar la complejidad del modelo de la capa completamente conectada. LeNet no utiliza el método de descarte.
En cuarto lugar, AlexNet introduce grandes mejoras de imagen, como voltear, recortar y cambiar el color para expandir aún más el conjunto de datos y aliviar el sobreajuste.

Implemente un AlexNet ligeramente simplificado.

import time
import torch
from torch import nn, optim
import torchvision

import sys
sys.path.append("..") 
import d2lzh_pytorch as d2l
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

print(torch.__version__)
print(torchvision.__version__)
print(device)
class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            # in_channels, out_channels, kernel_size, stride, padding
            nn.Conv2d(1, 96, 11, 4), 
            nn.ReLU(),
            # kernel_size, stride
            nn.MaxPool2d(3, 2), 
            # 减小卷积窗口,使用填充为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),
            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

Imprima para ver la estructura de la red.

AlexNet ( 
  (conv): Sequential ( 
    (0): Conv2d (1, 96, kernel_size = (11, 11), stride = (4, 4)) 
    (1): ReLU () 
    (2): MaxPool2d (kernel_size = 3 , stride = 2, padding = 0, dilatación = 1, ceil_mode = False) 
    (3): Conv2d (96, 256, kernel_size = (5, 5), stride = (1, 1), padding = (2, 2) ) 
    (4): ReLU () 
    (5): MaxPool2d (kernel_size = 3, stride = 2, padding = 0, dilatación = 1, ceil_mode = False) 
    (6): Conv2d (256, 384, kernel_size = (3, 3) ), stride = (1, 1), padding = (1, 1)) 
    (7): ReLU () 
    (8): Conv2d (384, 384, kernel_size = (3, 3), stride = (1, 1) , padding = (1, 1)) 
    (9): ReLU () 
    (10): Conv2d (384, 256, kernel_size = (3, 3), stride = (1, 1), padding = (1, 1)) 
    (11): ReLU ()
    (12): MaxPool2d (kernel_size = 3, stride = 2, padding = 0, dilatación = 1, ceil_mode = False) 
  ) 
  (fc): Sequential ( 
    (0): Linear (in_features = 6400, out_features = 4096, bias = True ) 
    (1): ReLU () 
    (2): Abandono (p = 0.5) 
    (3): Lineal (in_features = 4096, out_features = 4096, bias = True) 
    (4): ReLU () 
    (5): Abandono (p = 0.5) 
    (6): Lineal (in_features = 4096, out_features = 10, bias = True) 
  ) 
)

Leer datos

Aunque AlexNet usa el conjunto de datos ImageNet en el documento, debido a que el conjunto de datos ImageNet tarda mucho en entrenarse, todavía usamos el conjunto de datos Fashion-MNIST anterior para demostrar AlexNet. Al leer los datos, hacemos un paso adicional para ampliar la altura y el ancho de la imagen a la altura y el ancho de la imagen 224 utilizados por AlexNet. Esto se puede lograr mediante la instancia de torchvision.transforms.Resize . En otras palabras, usamos Resize antes de la instancia de ToTensor, y luego usamos la instancia de Compose para concatenar estas dos transformaciones para llamar.

# 本函数已保存在d2lzh_pytorch包中方便以后使用
def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    """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=4)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=4)

    return train_iter, test_iter
batch_size = 128
# 如出现“out of memory”的报错信息,可减小batch_size或resize
train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)

formación

Empiece a entrenar AlexNet. En comparación con LeNet, debido a que el tamaño de la imagen cambia y el modelo cambia , requiere una gran memoria de video y un largo tiempo de entrenamiento.

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)

Salida:

entrenamiento en cuda 
epoch 1, pérdida 0.0047, train acc 0.770, test acc 0.865, time 128.3 sec 
epoch 2, loss 0.0025, train acc 0.879, test acc 0.889, time 128.8 sec 
epoch 3, loss 0.0022, train acc 0.898, test acc 0.901 , tiempo 130.4 seg 
época 4, pérdida 0.0019, tren acc 0.908, prueba acc 0.900, tiempo 131.4 seg 
época 5, pérdida 0.0018, tren acc 0.913, prueba acc 0.902, tiempo 129.9 seg

resumen

  • AlexNet es similar a LeNet en estructura, pero usa capas más convolucionales y un espacio de parámetros más grande para adaptarse a un conjunto de datos a gran escala ImageNet . Es la línea divisoria entre la red neuronal superficial y la red neuronal profunda.
  • Aunque parece que la implementación de AlexNet es unos códigos más que la implementación de LeNet, el cambio de concepto y la producción de resultados experimentales verdaderamente excelentes le han costado a la comunidad académica muchos años.

Supongo que te gusta

Origin blog.csdn.net/dujuancao11/article/details/108572001
Recomendado
Clasificación