Inception V2 y V3: versiones de red de Inception

Inception V1 (o GoogLeNet) fue la arquitectura de vanguardia en ILSRVRC 2014. Ha producido el error más bajo récord en el conjunto de datos de clasificación de ImageNet, pero hay algunos puntos en los que se pueden mejorar para mejorar la precisión y disminuir la complejidad. del modelo 
Problemas de la arquitectura de Inception V1: 
Inception V1 a veces usa convoluciones como 5*5 que hace que las dimensiones de entrada disminuyan en un gran margen. Esto hace que la red neuronal utilice cierta disminución de la precisión. La razón por la que la red neuronal es susceptible a la pérdida de información si la dimensión de entrada disminuye demasiado drásticamente. 
Además, también hay una disminución de la complejidad cuando usamos circunvoluciones más grandes como 5 × 5 en comparación con 3 × 3. Podemos ir más allá en términos de factorización, es decir, podemos dividir una convolución de 3×3 en una convolución asimétrica de 1×3 seguida de una convolución de 3×1 . Esto es equivalente a deslizar una red de dos capas con el mismo campo receptivo que en una convolución de 3×3 pero un 33% más económica que la de 3×3 . Esta factorización no funciona bien para las primeras capas cuando las dimensiones de entrada son grandes, pero solo cuando el tamaño de entrada es mxm(m está entre 12 y 20). De acuerdo con la arquitectura Inception V1, el clasificador auxiliar mejora la convergencia de la red. Argumentan que puede ayudar a reducir el efecto del problema del gradiente de fuga en las redes profundas al empujar el gradiente útil a las capas anteriores (para reducir la pérdida). Sin embargo, los autores de este artículo encontraron que este clasificador no mejoró mucho la convergencia al principio del entrenamiento.
Cambios arquitectónicos en Inception V2 : 
En la arquitectura de Inception V2. La convolución de 5×5 se reemplaza por las dos convoluciones de 3×3 . Esto también reduce el tiempo de cálculo y, por lo tanto, aumenta la velocidad de cálculo porque una convolución de 5×5 es 2,78 más cara que una de 3×3.circunvolución. Entonces, el uso de dos capas de 3×3 en lugar de 5×5 aumenta el rendimiento de la arquitectura.
 

Figura 1

Esta arquitectura también convierte la factorización nXn en factorización 1xn y nx1. Como discutimos anteriormente, una convolución de 3 × 3 se puede convertir en 1 × 3 , seguida de una convolución de 3 × 1, que es un 33 % más barata en términos de complejidad computacional en comparación con 3 × 3 .
 

Figura 2

Para lidiar con el problema del cuello de botella de representación, los bancos de funciones del módulo se ampliaron en lugar de profundizarlo. Esto evitaría la pérdida de información que provoca cuando la hacemos más profunda. 
 

figura 3

Cambios arquitectónicos en Inception V3: 
Inception V3 es similar y contiene todas las características de Inception V2 con los siguientes cambios/adiciones: 
 

• Uso del optimizador RMSprop.
• Normalización por lotes en la capa totalmente conectada del clasificador auxiliar.
• Uso de convolución factorizada 7 × 7
• Regularización de suavizado de etiquetas: es un método para regularizar el clasificador al estimar el efecto de la caída de la etiqueta durante el entrenamiento. Evita que el clasificador prediga una clase con demasiada confianza. La adición del suavizado de etiquetas proporciona una mejora del 0,2 % en la tasa de error.

Arquitectura: 
a continuación se muestran los detalles capa por capa de Inception V2 : 
 

Arquitectura de inicio V2

La arquitectura anterior toma una entrada de imagen de tamaño (299,299,3) . Observe que en la arquitectura anterior, las figuras 5, 6, 7 se refieren a las figuras 1, 2, 3 en este artículo. 
Implementación: 
en esta sección analizaremos la implementación de Inception V3. Usaremos la API de aplicaciones de Keras para cargar el módulo. Estamos usando el conjunto de datos Cats vs Dogs para esta implementación. 
Código: Importando el módulo requerido. 
 

import os
import zipfile
import tensorflow as tf
from tensorflow.keras.optimizers import RMSprop
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras import layers
from tensorflow.keras import Model
from tensorflow.keras.applications.inception_v3 import InceptionV3
from tensorflow.keras.optimizers import RMSprop

Código: creación de directorios para prepararse para el conjunto de datos 
 

local_zip = '/dataset/cats_and_dogs_filtered.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp')
zip_ref.close()
 
base_dataset_dir = '/tmp/cats_and_dogs_filtered'
train_dir = os.path.join(base_dataset_dir, 'train')
validation_dir = os.path.join(base_dataset_dir, 'validation')
 
# Directory with our training cat pictures
train_cats = os.path.join(train_dir, 'cats')
 
# Directory with our training dog pictures
train_dogs = os.path.join(train_dir, 'dogs')
 
# Directory with our validation cat pictures
validation_cats = os.path.join(validation_dir, 'cats')
 
# Directory with our validation dog pictures
validation_dogs = os.path.join(validation_dir, 'dogs')

Código: almacenar el conjunto de datos en los directorios creados anteriormente y trazar algunas imágenes de muestra. 
 

# Set up matplotlib fig, and size it to fit 4x4 pics
import matplotlib.image as mpimg
nrows = 4
ncols = 4
 
fig = plt.gcf()
fig.set_size_inches(ncols*4, nrows*4)
pic_index = 100
train_cat_files = os.listdir( train_cats )
train_dog_files = os.listdir( train_dogs )
 
 
next_cat_img = [os.path.join(train_cats, fname)
                for fname in train_cat_files[ pic_index-8:pic_index]
               ]
 
next_dog_img = [os.path.join(train_dogs, fname)
                for fname in train_dog_files[ pic_index-8:pic_index]
               ]
 
for i, img_path in enumerate(next_cat_img+next_dog_img):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)
 
  img = mpimg.imread(img_path)
  plt.imshow(img)
 
plt.show()

Código: aumento de datos para aumentar las muestras de datos en el conjunto de datos. 
 

train_datagen = ImageDataGenerator(rescale = 1./255.,
                                   rotation_range = 50,
                                   width_shift_range = 0.2,
                                   height_shift_range = 0.2,
                                   zoom_range = 0.2,
                                   horizontal_flip = True)
 
test_datagen = ImageDataGenerator( rescale = 1.0/255. )
 
train_generator = train_datagen.flow_from_directory(train_dir,
                                                    batch_size = 20,
                                                    class_mode = 'binary',
                                                    target_size = (150, 150))    
 
validation_generator =  test_datagen.flow_from_directory( validation_dir,
                                                          batch_size  = 20,
                                                          class_mode  = 'binary',
                                                          target_size = (150, 150))

Código: Defina el modelo base usando la API de Inception que importamos anteriormente y la función de devolución de llamada para entrenar el modelo. 
 

base_model = InceptionV3(input_shape = (150, 150, 3),
                                include_top = False,
                                weights = 'imagenet')
for layer in base_model.layers:
  layer.trainable = False
 
#stop training is model accuracy reached 99%
class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('acc')>0.99):
      self.model.stop_training = True

En este paso, entrenamos nuestro modelo, pero antes del entrenamiento, necesitamos cambiar la última capa para que pueda predecir solo una salida y usar la función de optimización para el entrenamiento. Aquí usamos RMSprop con una tasa de aprendizaje de 0.0001. También agregamos un abandono 0.2 después de la última capa completamente conectada. Después de eso, entrenamos el modelo hasta 100 épocas. 
Código: 
 

# code
x = layers.Flatten()(base_model.output)
x = layers.Dense(1024, activation='relu')(x)
x = layers.Dropout(0.2)(x)                 
x = layers.Dense  (1, activation='sigmoid')(x)          
 
model = Model( base_model.input, x)
 
model.compile(optimizer = RMSprop(lr=0.0001),loss = 'binary_crossentropy',metrics = ['acc'])
callbacks = myCallback()
 
history = model.fit_generator(
            train_generator,
            validation_data = validation_generator,
            steps_per_epoch = 100,
            epochs = 100,
            validation_steps = 50,
            verbose = 2,
            callbacks=[callbacks])

Código: Trazar la precisión del entrenamiento y la validación junto con la pérdida del entrenamiento y la validación. 
 

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
 
epochs = range(len(acc))
 
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
 
plt.figure()
 
plt.plot(epochs, loss, 'r', label='Training Loss')
plt.plot(epochs, val_loss, 'b', label='Validation Loss')
plt.title('Training and validation loss')
plt.legend()

Resultados: 
la arquitectura Inception V3 de mejor desempeño reportó un error entre los 5 primeros de solo 5,6 % y un error entre los 1 primeros de 21,2 % para un solo cultivo en el desafío de clasificación de ILSVRC 2012, que es el nuevo estado del arte. En cultivos múltiples (144 cultivos) informó una tasa de error de 4.2% y 18.77% entre los 5 primeros y entre los 1 primeros en el punto de referencia de clasificación ILSVRC 2012. 

Rendimiento de Inception V3

Un conjunto de arquitectura Inception V3 informó una tasa de error entre los cinco primeros del 3,46 % del conjunto de validación de ILSVRC 2012 (3,58 % en el conjunto de prueba de ILSVRC 2012). 

Resultados de conjunto de Inception V3

Referencias : 
 

• Replanteamiento de la arquitectura de inicio para el documento de visión por computadora