Después de la primera arquitectura basada en CNN (AlexNet) que ganó la competencia ImageNet 2012, cada arquitectura ganadora posterior utiliza más capas en una red neuronal profunda para reducir la tasa de error. Esto funciona para una menor cantidad de capas, pero cuando aumentamos la cantidad de capas, hay un problema común en el aprendizaje profundo asociado con el llamado gradiente de desaparición/explosión. Esto hace que el gradiente se vuelva 0 o demasiado grande. Por lo tanto, cuando aumentamos el número de capas, la tasa de error de entrenamiento y prueba también aumenta.
Comparación de la arquitectura de 20 capas frente a la de 56 capas
En el gráfico anterior, podemos observar que una CNN de 56 capas proporciona una mayor tasa de error tanto en el conjunto de datos de entrenamiento como de prueba que una arquitectura de CNN de 20 capas. Después de analizar más la tasa de error, los autores pudieron llegar a la conclusión de que se debe a un gradiente de desaparición/explosión.
ResNet, que fue propuesto en 2015 por investigadores de Microsoft Research, introdujo una nueva arquitectura llamada Residual Network.
Red Residual: Para resolver el problema del gradiente que desaparece/explota, esta arquitectura introdujo el concepto llamado Bloques Residuales. En esta red, usamos una técnica llamada saltar conexiones . La conexión de salto conecta las activaciones de una capa con otras capas omitiendo algunas capas intermedias. Esto forma un bloque residual. Los Resnets se hacen apilando estos bloques residuales juntos.
El enfoque detrás de esta red es que, en lugar de que las capas aprendan el mapeo subyacente, permitimos que la red se ajuste al mapeo residual. Entonces, en lugar de decir H(x), mapeo inicial , deje que la red se ajuste,
F(x) := H(x) - x which gives H(x) := F(x) + x.
Saltar (acceso directo) conexión
La ventaja de agregar este tipo de conexión de omisión es que si alguna capa daña el rendimiento de la arquitectura, la regularización la omitirá. Entonces, esto da como resultado el entrenamiento de una red neuronal muy profunda sin los problemas causados por el gradiente de desaparición/explosión. Los autores del artículo experimentaron con 100-1000 capas del conjunto de datos CIFAR-10.
Hay un enfoque similar llamado «redes de carreteras», estas redes también usan conexión de salto. Al igual que LSTM, estas conexiones de salto también usan puertas paramétricas. Estas puertas determinan cuánta información pasa a través de la conexión de salto. Sin embargo, esta arquitectura no ha proporcionado una precisión mejor que la arquitectura ResNet.
Arquitectura de red: esta red utiliza una arquitectura de red simple de 34 capas inspirada en VGG-19 en la que luego se agrega la conexión de acceso directo. Estas conexiones de acceso directo luego convierten la arquitectura en una red residual.
Arquitectura ResNet-34
Implementación: con la API de Tensorflow y Keras, podemos diseñar la arquitectura ResNet (incluidos los bloques residuales) desde cero. A continuación se muestra la implementación de diferentes arquitecturas ResNet. Para esta implementación, utilizamos el conjunto de datos CIFAR-10. Este conjunto de datos contiene 60 000 imágenes en color de 32 × 32 en 10 clases diferentes (aviones, automóviles, pájaros, gatos, ciervos, perros, ranas, caballos, barcos y camiones), etc. Este conjunto de datos se puede evaluar desde k eras.datasets Función API.
Paso 1: Primero, importamos el módulo keras y sus API. Estas API ayudan a construir la arquitectura del modelo ResNet.
Código: Importación de bibliotecas
# Import Keras modules and its important APIs import keras from keras.layers import Dense, Conv2D, BatchNormalization, Activation from keras.layers import AveragePooling2D, Input, Flatten from keras.optimizers import Adam from keras.callbacks import ModelCheckpoint, LearningRateScheduler from keras.callbacks import ReduceLROnPlateau from keras.preprocessing.image import ImageDataGenerator from keras.regularizers import l2 from keras import backend as K from keras.models import Model from keras.datasets import cifar10 import numpy as np import os
Paso 2: Ahora, establecemos diferentes hiperparámetros que se requieren para la arquitectura ResNet. También hicimos un preprocesamiento en nuestro conjunto de datos para prepararlo para el entrenamiento.
Código: configuración de hiperparámetros de entrenamiento
python3
# Setting Training Hyperparameters
batch_size = 32 # original ResNet paper uses batch_size = 128 for training
epochs = 200
data_augmentation = True
num_classes = 10
# Data Preprocessing
subtract_pixel_mean = True
n = 3
# Select ResNet Version
version = 1
# Computed depth of
if version == 1:
depth = n * 6 + 2
elif version == 2:
depth = n * 9 + 2
# Model name, depth and version
model_type = 'ResNet % dv % d' % (depth, version)
# Load the CIFAR-10 data.
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Input image dimensions.
input_shape = x_train.shape[1:]
# Normalize data.
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# If subtract pixel mean is enabled
if subtract_pixel_mean:
x_train_mean = np.mean(x_train, axis = 0)
x_train -= x_train_mean
x_test -= x_train_mean
# Print Training and Test Samples
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
print('y_train shape:', y_train.shape)
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
Paso 3: En este paso, establecemos la tasa de aprendizaje según el número de épocas. A medida que aumenta el número de épocas, la tasa de aprendizaje debe disminuir para garantizar un mejor aprendizaje.
Código: configuración de LR para diferentes números de épocas
python3
# Setting LR for different number of Epochs
def lr_schedule(epoch):
lr = 1e-3
if epoch > 180:
lr *= 0.5e-3
elif epoch > 160:
lr *= 1e-3
elif epoch > 120:
lr *= 1e-2
elif epoch > 80:
lr *= 1e-1
print('Learning rate: ', lr)
return lr
Paso 4: Defina el componente básico de ResNet que se puede usar para definir la arquitectura ResNet V1 y V2.
Código: Bloque de creación básico de ResNet
python3
# Basic ResNet Building Block def resnet_layer(inputs, num_filters=16, kernel_size=3, strides=1, activation='relu', batch_normalization=True, conv=Conv2D(num_filters, kernel_size=kernel_size, strides=strides, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4)) x=inputs if conv_first: x = conv(x) if batch_normalization: x = BatchNormalization()(x) if activation is not None: x = Activation(activation)(x) else: if batch_normalization: x = BatchNormalization()(x) if activation is not None: x = Activation(activation)(x) x = conv(x) return x
Paso 5: Defina la arquitectura ResNet V1 que se basa en el bloque de construcción ResNet que definimos anteriormente:
Código: arquitectura ResNet V1
python3
def resnet_v1(input_shape, depth, num_classes=10):
if (depth - 2) % 6 != 0:
raise ValueError('depth should be 6n + 2 (eg 20, 32, 44 in [a])')
# Start model definition.
num_filters = 16
num_res_blocks = int((depth - 2) / 6)
inputs = Input(shape=input_shape)
x = resnet_layer(inputs=inputs)
# Instantiate the stack of residual units
for stack in range(3):
for res_block in range(num_res_blocks):
strides = 1
if stack & gt
0 and res_block == 0: # first layer but not first stack
strides = 2 # downsample
y = resnet_layer(inputs=x,
num_filters=num_filters,
strides=strides)
y = resnet_layer(inputs=y,
num_filters=num_filters,
activation=None)
if stack & gt
0 and res_block == 0: # first layer but not first stack
# linear projection residual shortcut connection to match
# changed dims
x = resnet_layer(inputs=x,
num_filters=num_filters,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
x = keras.layers.add([x, y])
x = Activation('relu')(x)
num_filters *= 2
# Add classifier on top.
# v1 does not use BN after last shortcut connection-ReLU
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
Paso 6: Defina la arquitectura ResNet V2 que se basa en el bloque de construcción ResNet que definimos anteriormente:
Código: arquitectura ResNet V2
python3
# ResNet V2 architecture
def resnet_v2(input_shape, depth, num_classes=10):
if (depth - 2) % 9 != 0:
raise ValueError('depth should be 9n + 2 (eg 56 or 110 in [b])')
# Start model definition.
num_filters_in = 16
num_res_blocks = int((depth - 2) / 9)
inputs = Input(shape=input_shape)
# v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
x = resnet_layer(inputs=inputs,
num_filters=num_filters_in,
conv_first=True)
# Instantiate the stack of residual units
for stage in range(3):
for res_block in range(num_res_blocks):
activation = 'relu'
batch_normalization = True
strides = 1
if stage == 0:
num_filters_out = num_filters_in * 4
if res_block == 0: # first layer and first stage
activation = None
batch_normalization = False
else:
num_filters_out = num_filters_in * 2
if res_block == 0: # first layer but not first stage
strides = 2 # downsample
# bottleneck residual unit
y = resnet_layer(inputs=x,
num_filters=num_filters_in,
kernel_size=1,
strides=strides,
activation=activation,
batch_normalization=batch_normalization,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_in,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_out,
kernel_size=1,
conv_first=False)
if res_block == 0:
# linear projection residual shortcut connection to match
# changed dims
x = resnet_layer(inputs=x,
num_filters=num_filters_out,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
x = keras.layers.add([x, y])
num_filters_in = num_filters_out
# Add classifier on top.
# v2 has BN-ReLU before Pooling
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
Paso 7: El siguiente código se usa para entrenar y probar la arquitectura ResNet v1 y v2 que definimos anteriormente:
Código: función principal
python3
# Main function
if version == 2:
model = resnet_v2(input_shape = input_shape, depth = depth)
else:
model = resnet_v1(input_shape = input_shape, depth = depth)
model.compile(loss ='categorical_crossentropy',
optimizer = Adam(learning_rate = lr_schedule(0)),
metrics =['accuracy'])
model.summary()
print(model_type)
# Prepare model saving directory.
save_dir = os.path.join(os.getcwd(), 'saved_models')
model_name = 'cifar10_% s_model.{epoch:03d}.h5' % model_type
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
filepath = os.path.join(save_dir, model_name)
# Prepare callbacks for model saving and for learning rate adjustment.
checkpoint = ModelCheckpoint(filepath = filepath,
monitor ='val_acc',
verbose = 1,
save_best_only = True)
lr_scheduler = LearningRateScheduler(lr_schedule)
lr_reducer = ReduceLROnPlateau(factor = np.sqrt(0.1),
cooldown = 0,
patience = 5,
min_lr = 0.5e-6)
callbacks = [checkpoint, lr_reducer, lr_scheduler]
# Run training, with or without data augmentation.
if not data_augmentation:
print('Not using data augmentation.')
model.fit(x_train, y_train,
batch_size = batch_size,
epochs = epochs,
validation_data =(x_test, y_test),
shuffle = True,
callbacks = callbacks)
else:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen = ImageDataGenerator(
# set input mean to 0 over the dataset
featurewise_center = False,
# set each sample mean to 0
samplewise_center = False,
# divide inputs by std of dataset
featurewise_std_normalization = False,
# divide each input by its std
samplewise_std_normalization = False,
# apply ZCA whitening
zca_whitening = False,
# epsilon for ZCA whitening
zca_epsilon = 1e-06,
# randomly rotate images in the range (deg 0 to 180)
rotation_range = 0,
# randomly shift images horizontally
width_shift_range = 0.1,
# randomly shift images vertically
height_shift_range = 0.1,
# set range for random shear
shear_range = 0.,
# set range for random zoom
zoom_range = 0.,
# set range for random channel shifts
channel_shift_range = 0.,
# set mode for filling points outside the input boundaries
fill_mode ='nearest',
# value used for fill_mode = "constant"
cval = 0.,
# randomly flip images
horizontal_flip = True,
# randomly flip images
vertical_flip = False,
# set rescaling factor (applied before any other transformation)
rescale = None,
# set function that will be applied on each input
preprocessing_function = None,
# image data format, either "channels_first" or "channels_last"
data_format = None,
# fraction of images reserved for validation (strictly between 0 and 1)
validation_split = 0.0)
# Compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train, batch_size = batch_size),
validation_data =(x_test, y_test),
epochs = epochs, verbose = 1, workers = 4,
callbacks = callbacks)
# Score trained model.
scores = model.evaluate(x_test, y_test, verbose = 1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
Resultados y conclusión:
en el conjunto de datos de ImageNet, los autores usan una ResNet de 152 capas, que es 8 veces más profunda que VGG19 pero aún tiene menos parámetros. Un conjunto de estas ResNet generó un error de solo el 3,7 % en el conjunto de prueba de ImageNet, resultado que ganó la competencia ILSVRC 2015. En el conjunto de datos de detección de objetos COCO, también genera una mejora relativa del 28% debido a su representación muy profunda.
Tasa de error en la arquitectura ResNet
- El resultado anterior muestra que las conexiones de acceso directo podrían resolver el problema causado por el aumento de las capas porque a medida que aumentamos las capas de 18 a 34, la tasa de error en el conjunto de validación de ImageNet también disminuye a diferencia de la red simple.
tasa de error top-1 y top-5 en el conjunto de validación de ImageNet.
- A continuación se muestran los resultados en el conjunto de prueba de ImageNet. La tasa de error del 3,57% entre los 5 primeros de ResNet fue la más baja y, por lo tanto, la arquitectura ResNet ocupó el primer lugar en el desafío de clasificación de ImageNet en 2015.
Referencias: