El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, exploraremos algunas de las arquitecturas más avanzadas y populares de Redes Neuronales Convolucionales (CNNs). Estas arquitecturas han demostrado ser extremadamente efectivas en una variedad de tareas de visión por computadora y han ganado múltiples competiciones en el campo. Aprenderemos sobre las siguientes arquitecturas:

AlexNet
VGGNet
Inception
ResNet

AlexNet

Descripción

AlexNet fue una de las primeras arquitecturas de CNN en demostrar un rendimiento superior en la competencia ImageNet en 2012. Introdujo varias innovaciones clave, como el uso de ReLU en lugar de funciones de activación sigmoide y el uso de dropout para reducir el sobreajuste.

Arquitectura

Capas Convolucionales: 5
Capas Fully Connected: 3
Funciones de Activación: ReLU
Dropout: Sí
Normalización Local de Respuesta (LRN): Sí

Implementación en TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models

def create_alexnet():
    model = models.Sequential()
    model.add(layers.Conv2D(96, (11, 11), strides=4, activation='relu', input_shape=(227, 227, 3)))
    model.add(layers.MaxPooling2D((3, 3), strides=2))
    model.add(layers.Conv2D(256, (5, 5), padding='same', activation='relu'))
    model.add(layers.MaxPooling2D((3, 3), strides=2))
    model.add(layers.Conv2D(384, (3, 3), padding='same', activation='relu'))
    model.add(layers.Conv2D(384, (3, 3), padding='same', activation='relu'))
    model.add(layers.Conv2D(256, (3, 3), padding='same', activation='relu'))
    model.add(layers.MaxPooling2D((3, 3), strides=2))
    model.add(layers.Flatten())
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(1000, activation='softmax'))
    return model

alexnet = create_alexnet()
alexnet.summary()

VGGNet

Descripción

VGGNet, desarrollado por el Visual Geometry Group de la Universidad de Oxford, se destacó en la competencia ImageNet 2014. Su principal contribución fue demostrar que la profundidad de la red es un factor crítico para el rendimiento.

Arquitectura

Capas Convolucionales: 16-19
Capas Fully Connected: 3
Funciones de Activación: ReLU
Tamaño de Filtro: 3x3

Implementación en TensorFlow

def create_vgg16():
    model = models.Sequential()
    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3)))
    model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same'))
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(256, (3, 3), activation='relu', padding='same'))
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.Conv2D(512, (3, 3), activation='relu', padding='same'))
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Flatten())
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dense(1000, activation='softmax'))
    return model

vgg16 = create_vgg16()
vgg16.summary()

Inception

Descripción

La arquitectura Inception, también conocida como GoogLeNet, fue introducida por Google en 2014. Su principal innovación es el uso de módulos Inception, que permiten a la red elegir entre múltiples tamaños de filtro en cada capa.

Arquitectura

Módulos Inception: Sí
Capas Convolucionales: Varias
Capas Fully Connected: 1
Funciones de Activación: ReLU

Implementación en TensorFlow

def inception_module(x, filters):
    f1, f3_r, f3, f5_r, f5, pool_proj = filters
    
    conv1 = layers.Conv2D(f1, (1, 1), padding='same', activation='relu')(x)
    
    conv3 = layers.Conv2D(f3_r, (1, 1), padding='same', activation='relu')(x)
    conv3 = layers.Conv2D(f3, (3, 3), padding='same', activation='relu')(conv3)
    
    conv5 = layers.Conv2D(f5_r, (1, 1), padding='same', activation='relu')(x)
    conv5 = layers.Conv2D(f5, (5, 5), padding='same', activation='relu')(conv5)
    
    pool = layers.MaxPooling2D((3, 3), strides=(1, 1), padding='same')(x)
    pool = layers.Conv2D(pool_proj, (1, 1), padding='same', activation='relu')(pool)
    
    return layers.concatenate([conv1, conv3, conv5, pool], axis=-1)

def create_inception():
    input_layer = layers.Input(shape=(224, 224, 3))
    x = layers.Conv2D(64, (7, 7), strides=2, padding='same', activation='relu')(input_layer)
    x = layers.MaxPooling2D((3, 3), strides=2, padding='same')(x)
    x = layers.Conv2D(192, (3, 3), padding='same', activation='relu')(x)
    x = layers.MaxPooling2D((3, 3), strides=2, padding='same')(x)
    
    x = inception_module(x, [64, 96, 128, 16, 32, 32])
    x = inception_module(x, [128, 128, 192, 32, 96, 64])
    x = layers.MaxPooling2D((3, 3), strides=2, padding='same')(x)
    
    x = inception_module(x, [192, 96, 208, 16, 48, 64])
    x = inception_module(x, [160, 112, 224, 24, 64, 64])
    x = inception_module(x, [128, 128, 256, 24, 64, 64])
    x = inception_module(x, [112, 144, 288, 32, 64, 64])
    x = inception_module(x, [256, 160, 320, 32, 128, 128])
    x = layers.MaxPooling2D((3, 3), strides=2, padding='same')(x)
    
    x = inception_module(x, [256, 160, 320, 32, 128, 128])
    x = inception_module(x, [384, 192, 384, 48, 128, 128])
    
    x = layers.GlobalAveragePooling2D()(x)
    output_layer = layers.Dense(1000, activation='softmax')(x)
    
    model = models.Model(input_layer, output_layer)
    return model

inception = create_inception()
inception.summary()

ResNet

Descripción

ResNet, o Redes Residuales, fue introducida por Microsoft en 2015 y ganó la competencia ImageNet. Su principal innovación es el uso de conexiones residuales, que permiten entrenar redes mucho más profundas sin problemas de degradación.

Arquitectura

Bloques Residuales: Sí
Capas Convolucionales: Varias
Capas Fully Connected: 1
Funciones de Activación: ReLU

Implementación en TensorFlow

def residual_block(x, filters, kernel_size=3, stride=1, conv_shortcut=True):
    if conv_shortcut:
        shortcut = layers.Conv2D(4 * filters, 1, strides=stride)(x)
        shortcut = layers.BatchNormalization()(shortcut)
    else:
        shortcut = x

    x = layers.Conv2D(filters, 1, strides=stride)(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation('relu')(x)

    x = layers.Conv2D(filters, kernel_size, padding='same')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation('relu')(x)

    x = layers.Conv2D(4 * filters, 1)(x)
    x = layers.BatchNormalization()(x)

    x = layers.add([shortcut, x])
    x = layers.Activation('relu')(x)
    return x

def create_resnet50():
    input_layer = layers.Input(shape=(224, 224, 3))
    x = layers.Conv2D(64, 7, strides=2, padding='same')(input_layer)
    x = layers.BatchNormalization()(x)
    x = layers.Activation('relu')(x)
    x = layers.MaxPooling2D(3, strides=2, padding='same')(x)

    x = residual_block(x, 64, conv_shortcut=False)
    x = residual_block(x, 64)
    x = residual_block(x, 64)

    x = residual_block(x, 128, stride=2)
    x = residual_block(x, 128)
    x = residual_block(x, 128)
    x = residual_block(x, 128)

    x = residual_block(x, 256, stride=2)
    x = residual_block(x, 256)
    x = residual_block(x, 256)
    x = residual_block(x, 256)
    x = residual_block(x, 256)
    x = residual_block(x, 256)

    x = residual_block(x, 512, stride=2)
    x = residual_block(x, 512)
    x = residual_block(x, 512)

    x = layers.GlobalAveragePooling2D()(x)
    output_layer = layers.Dense(1000, activation='softmax')(x)

    model = models.Model(input_layer, output_layer)
    return model

resnet50 = create_resnet50()
resnet50.summary()

Conclusión

En esta sección, hemos explorado algunas de las arquitecturas más avanzadas de CNN, incluyendo AlexNet, VGGNet, Inception y ResNet. Cada una de estas arquitecturas ha contribuido significativamente al campo de la visión por computadora y ha introducido innovaciones clave que han mejorado el rendimiento de las redes neuronales. En el próximo módulo, profundizaremos en las Redes Neuronales Recurrentes (RNNs) y sus aplicaciones.

Arquitecturas Avanzadas de CNN

AlexNet

Descripción

Arquitectura

Implementación en TensorFlow

VGGNet

Descripción

Arquitectura

Implementación en TensorFlow

Inception

Descripción

Arquitectura

Implementación en TensorFlow

ResNet

Descripción

Arquitectura

Implementación en TensorFlow

Conclusión

Curso de TensorFlow

Módulo 1: Introducción a TensorFlow

Módulo 2: Fundamentos de TensorFlow

Módulo 3: Manejo de Datos en TensorFlow

Módulo 4: Construcción de Redes Neuronales

Módulo 5: Redes Neuronales Convolucionales (CNNs)

Módulo 6: Redes Neuronales Recurrentes (RNNs)

Módulo 7: Técnicas Avanzadas de TensorFlow

Módulo 8: TensorFlow para Producción

Módulo 9: TensorFlow Extendido (TFX)

Módulo 10: Temas Especiales