Creación de red convolucional para clasificación

¿Por qué se utiliza una función de activación (en este caso ReLU) en la capa de extracción de características / feature maps?

Como se vió en el curso pasado, en una red neuronal artificial la función de activación es usada debido a que la salida de las neuronas artificiales da como resultado una función lineal y por lo tanto la suma de funciones lineales da como resultado otra función lineal.

En el caso de las redes neuronales convolucionales, la función de activación también es usada en la extracción de características/ feature maps debido a que ésta misma consta de 3 operaciones básicas:

• Filtrar una imagen para una característica en particular (convolución)
• Detectar esa característica dentro de la imagen filtrada (ReLU)
• Condensar la imagen para realzar las características (pooling)

Aquí una imagen para ilustrar lo mencionado anteriormente:

El código:

model = Sequential()
## conv 1
model.add(Conv2D(base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer),
                 input_shape=x_train.shape[1:]))

model.add(Activation('relu'))

## conv 2
model.add(Conv2D(base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.2))

## conv 3
model.add(Conv2D(2*base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer)))
model.add(Activation('relu'))

## conv 4
model.add(Conv2D(2*base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.3))

## conv 5
model.add(Conv2D(4*base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer)))
model.add(Activation('relu'))

## conv 6
model.add(Conv2D(4*base_filtros, (3,3), padding="same", 
                 kernel_regularizer=regularizers.l2(w_regularizer)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.4))

## Clasificación-Flatten
model.add(Flatten())
model.add(Dense(num_class, activation='softmax'))

model.summary()

En CNNs, `base_filters` (p. ej., 32) ajusta la complejidad inicial. `w_regularizer` (p. ej., 1e-4) controla la penalización de pesos para prevenir sobreajuste. Ajustar estos valores impacta en la capacidad de aprendizaje y generalización del modelo

\### Creación de una Red Neuronal Convolucional (CNN) para Clasificación Una \*\*Red Neuronal Convolucional (CNN)\*\* es un tipo de red neuronal diseñada específicamente para procesar datos con una estructura de cuadrícula, como las imágenes. Se utiliza principalmente en tareas de visión por computadora, como clasificación, detección de objetos y segmentación de imágenes. \### Componentes Clave de una CNN 1\. \*\*Capa Convolucional (Conv Layer):\*\* La CNN aplica filtros (kernels) sobre la imagen de entrada, que extraen características locales como bordes, texturas o patrones. 2\. \*\*Capa de Activación (ReLU):\*\* Introduce no linealidades en la red, lo que permite que la red aprenda funciones más complejas. 3\. \*\*Capa de Pooling (Max Pooling):\*\* Reduce las dimensiones de las características extraídas para hacer el modelo más eficiente y evitar sobreajuste. 4\. \*\*Capas Completamente Conectadas (Dense Layers):\*\* Después de las capas convolucionales, los datos se aplanan y se conectan a neuronas para clasificar las características extraídas. \### Ejemplo: Creación de una CNN para Clasificar el Dataset \*\*CIFAR-10\*\* El dataset CIFAR-10 contiene imágenes de 10 clases diferentes, como aviones, automóviles, pájaros, gatos, etc. \#### Paso 1: Importar las librerías necesarias ```python import tensorflow as tf from tensorflow.keras import datasets, layers, models import matplotlib.pyplot as plt \# Cargar el dataset CIFAR-10 (train\_images, train\_labels), (test\_images, test\_labels) = datasets.cifar10.load\_data() \# Normalizar las imágenes entre 0 y 1 train\_images, test\_images = train\_images / 255.0, test\_images / 255.0 ``` \- \*\*CIFAR-10:\*\* Consiste en 60,000 imágenes de tamaño 32x32 y 3 canales (RGB). \- Las imágenes se normalizan para que los valores de los píxeles estén entre 0 y 1, facilitando el entrenamiento del modelo. \#### Paso 2: Visualizar algunas imágenes del dataset ```python \# Definir las clases de CIFAR-10 class\_names = \['Avión', 'Automóvil', 'Pájaro', 'Gato', 'Ciervo', 'Perro', 'Rana', 'Caballo', 'Barco', 'Camión'] \# Visualizar las primeras 9 imágenes del conjunto de entrenamiento plt.figure(figsize=(10,10)) for i in range(9): plt.subplot(3,3,i+1) plt.xticks(\[]) # Quitar marcas de los ejes x plt.yticks(\[]) # Quitar marcas de los ejes y plt.grid(False) plt.imshow(train\_images\[i]) plt.xlabel(class\_names\[train\_labels\[i]\[0]]) plt.show() ``` \#### Paso 3: Definir la arquitectura de la CNN ```python \# Definir el modelo CNN model = models.Sequential() \# Primera capa convolucional model.add(layers.Conv2D(32, (3, 3), activation='relu', input\_shape=(32, 32, 3))) model.add(layers.MaxPooling2D((2, 2))) \# Segunda capa convolucional model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) \# Tercera capa convolucional model.add(layers.Conv2D(64, (3, 3), activation='relu')) \# Aplanar los datos model.add(layers.Flatten()) \# Añadir una capa completamente conectada model.add(layers.Dense(64, activation='relu')) \# Capa de salida con 10 neuronas (una para cada clase) model.add(layers.Dense(10, activation='softmax')) \# Ver el resumen del modelo model.summary() ``` \### Explicación del Modelo 1\. \*\*Capas Convolucionales:\*\* \- Se utilizan tres capas convolucionales, cada una aplicando un filtro sobre la imagen. \- La primera capa convolucional usa 32 filtros de tamaño 3x3. Las siguientes dos capas utilizan 64 filtros de 3x3. \- Cada capa es seguida por una capa de \*\*MaxPooling2D\*\*, que reduce las dimensiones de las características. 2\. \*\*Capa de Aplanamiento (Flatten):\*\* \- Aplana las características aprendidas por las capas convolucionales para conectarlas a una capa densa. 3\. \*\*Capas Densas:\*\* \- La capa completamente conectada tiene 64 neuronas, que detectan combinaciones de las características extraídas. \- La capa de salida tiene 10 neuronas, cada una correspondiente a una clase de CIFAR-10, y usa la activación \*\*softmax\*\* para generar probabilidades de clasificación. \#### Paso 4: Compilar y entrenar el modelo ```python \# Compilar el modelo model.compile(optimizer='adam', loss='sparse\_categorical\_crossentropy', metrics=\['accuracy']) \# Entrenar el modelo history = model.fit(train\_images, train\_labels, epochs=10, validation\_data=(test\_images, test\_labels)) ``` \- \*\*Optimizador Adam:\*\* Se utiliza para actualizar los pesos del modelo. \- \*\*Función de pérdida:\*\* `sparse\_categorical\_crossentropy` porque estamos tratando con clasificación de múltiples clases. \- El modelo se entrena durante 10 épocas. \#### Paso 5: Evaluar el rendimiento del modelo ```python \# Evaluar el modelo en el conjunto de prueba test\_loss, test\_acc = model.evaluate(test\_images, test\_labels, verbose=2) print(f"Precisión en el conjunto de prueba: {test\_acc:.4f}") ``` \- El modelo se evalúa en el conjunto de prueba, y se imprime la precisión. \#### Paso 6: Visualizar las métricas de entrenamiento ```python \# Graficar la precisión del entrenamiento y validación plt.plot(history.history\['accuracy'], label='Precisión de entrenamiento') plt.plot(history.history\['val\_accuracy'], label='Precisión de validación') plt.xlabel('Época') plt.ylabel('Precisión') plt.legend(loc='lower right') plt.show() \# Graficar la pérdida del entrenamiento y validación plt.plot(history.history\['loss'], label='Pérdida de entrenamiento') plt.plot(history.history\['val\_loss'], label='Pérdida de validación') plt.xlabel('Época') plt.ylabel('Pérdida') plt.legend(loc='upper right') plt.show() ``` \### Conclusión En este ejercicio hemos creado una \*\*red neuronal convolucional\*\* para clasificar imágenes del dataset CIFAR-10. El modelo consiste en capas convolucionales y de pooling que extraen características de las imágenes y capas densas que clasifican las características aprendidas. Este proceso es fundamental para las aplicaciones de visión por computadora, como el reconocimiento de objetos o clasificación automática de imágenes.