El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Construyendo una CNN

Siguiente ►
►

En este tema, aprenderemos a construir una Red Neuronal Convolucional (CNN) utilizando TensorFlow. Las CNNs son especialmente efectivas para tareas de visión por computadora, como el reconocimiento de imágenes y la clasificación. Vamos a desglosar el proceso paso a paso, desde la preparación de los datos hasta la construcción y entrenamiento del modelo.

Objetivos

  • Comprender la estructura básica de una CNN.
  • Aprender a construir una CNN utilizando TensorFlow y Keras.
  • Entrenar y evaluar la CNN en un conjunto de datos de imágenes.

  1. Preparación del Entorno

Antes de comenzar, asegúrate de tener TensorFlow instalado. Puedes instalarlo utilizando pip:

pip install tensorflow

  1. Importación de Librerías

Primero, importemos las librerías necesarias:

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

  1. Cargando y Preprocesando los Datos

Utilizaremos el conjunto de datos CIFAR-10, que contiene 60,000 imágenes de 32x32 píxeles en 10 clases diferentes.

# Cargar el conjunto de datos CIFAR-10
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# Normalizar los valores de los píxeles a un rango de 0 a 1
train_images, test_images = train_images / 255.0, test_images / 255.0

  1. Exploración de los Datos

Es útil visualizar algunas imágenes del conjunto de datos para entender mejor con qué estamos trabajando.

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

# Mostrar las primeras 25 imágenes del conjunto de entrenamiento
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i][0]])
plt.show()

  1. Construcción del Modelo CNN

Ahora, construimos la CNN utilizando la API de Keras en TensorFlow. Nuestra CNN tendrá varias capas convolucionales y de pooling, seguidas de capas densas.

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

Explicación de las Capas

  • Conv2D: Capa convolucional que aplica filtros de convolución a la entrada.
  • MaxPooling2D: Capa de pooling que reduce la dimensionalidad de la entrada.
  • Flatten: Aplana la entrada para que pueda ser alimentada a una capa densa.
  • Dense: Capa completamente conectada.

  1. Compilación del Modelo

Compilamos el modelo especificando el optimizador, la función de pérdida y las métricas.

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

  1. Entrenamiento del Modelo

Entrenamos el modelo utilizando los datos de entrenamiento.

history = model.fit(train_images, train_labels, epochs=10, 
                    validation_data=(test_images, test_labels))

  1. Evaluación del Modelo

Evaluamos el modelo utilizando los datos de prueba para ver su rendimiento.

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'\nTest accuracy: {test_acc}')

  1. Visualización de Resultados

Podemos visualizar la precisión y la pérdida durante el entrenamiento y la validación.

plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0, 1])
plt.legend(loc='lower right')
plt.show()

Ejercicio Práctico

Ejercicio

Modifica la arquitectura de la CNN para mejorar su precisión. Prueba añadiendo más capas convolucionales o cambiando los hiperparámetros.

Solución

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))

model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(10))

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

history = model.fit(train_images, train_labels, epochs=10, 
                    validation_data=(test_images, test_labels))

Conclusión

En esta sección, hemos aprendido a construir una CNN básica utilizando TensorFlow y Keras. Hemos cubierto desde la carga y preprocesamiento de datos hasta la construcción, entrenamiento y evaluación del modelo. En el siguiente módulo, profundizaremos en arquitecturas avanzadas de CNN y técnicas para mejorar el rendimiento de nuestros modelos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados