No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Creación de red convolucional para clasificación

14/25
Recursos

Aportes 6

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

¿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()

Al ver este taller, me queda claro que las redes neuronales cuando no se hacen con transfer learning, son una obra de arte o un tiro al aire para ver si le o no debido a la cantidad de hiperparametros de estos modelos de redes neuronales. Todas se van a adaptar al problema en cuestion y cuando llegue información nueva a la red neuronal esta se va a eloquecer nuevamente. Luego para entender que esta pasando en la red neuronal es un complique porque son modelos de caja negra y unicamente con shapley o alguna libreria de ese estilo sabra que esta pasando.

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

En resumen, el modelo, tiene varias capas convolucionales con activaciones ReLU, capas de pooling para reducir la dimensión espacial, capas de dropout para reducir el sobreajuste, una capa densa para la clasificación y una capa Flatten para convertir los datos. El modelo tiene un total de 307,498 parámetros entrenables, lo que es genial. Esta clase se me hizo muy larga pero fue muy buena

\### 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.