13.3 Proyecto 3: Clasificación de Imágenes con Redes Neuronales Convolucionales

En este proyecto, desarrollaremos un modelo de clasificación de imágenes utilizando Redes Neuronales Convolucionales (CNN). La clasificación de imágenes es una aplicación común del aprendizaje profundo y consiste en determinar la clase de un objeto presente en una imagen.

13.3.1 Declaración del Problema

El objetivo de este proyecto es construir un modelo que pueda clasificar con precisión imágenes del conjunto de datos CIFAR-10. El conjunto de datos CIFAR-10 consta de 60,000 imágenes a color de 32x32 píxeles en 10 clases, con 6,000 imágenes por clase. Hay 50,000 imágenes de entrenamiento y 10,000 imágenes de prueba.

13.3.2 Conjunto de Datos

Utilizaremos el conjunto de datos CIFAR-10 para este proyecto. Este conjunto de datos consta de 60,000 imágenes a color de 32x32 píxeles en 10 clases, con 6,000 imágenes por clase. Hay 50,000 imágenes de entrenamiento y 10,000 imágenes de prueba.

13.3.3 Implementación

Comencemos cargando el conjunto de datos.

from keras.datasets import cifar10

# Load CIFAR-10 dataset
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

Desglose del código:

El código primero importa el conjunto de datos cifar10 de la biblioteca keras.datasets. A continuación, el código utiliza la función load_data() para cargar el conjunto de datos. La función load_data() devuelve dos tuplas, (X_train, y_train) y (X_test, y_test). Las matrices X_train y X_test contienen los datos de entrenamiento y prueba, respectivamente. Las matrices y_train y y_test contienen las etiquetas para los datos de entrenamiento y prueba, respectivamente. Las etiquetas son enteros del 0 al 9, donde 0 corresponde a la clase de aviones, 1 corresponde a la clase de automóviles, y así sucesivamente.

A continuación, preprocesaremos los datos normalizando los valores de los píxeles.

# Normalize pixel values to range [0, 1]
X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255

Desglose del código:

X_train = X_train.astype('float32') convierte el conjunto de datos de entrenamiento al tipo de datos float32.
X_train / 255 divide cada valor de píxel en el conjunto de datos de entrenamiento por 255.
X_test = X_test.astype('float32') convierte el conjunto de datos de prueba al tipo de datos float32.
X_test / 255 divide cada valor de píxel en el conjunto de datos de prueba por 255.

A continuación, convertiremos las etiquetas de clase en vectores codificados en one-hot (una-hot).

from keras.utils import to_categorical

# Convert class labels to one-hot encoded format
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

Desglose del código:

from keras.utils import to_categorical importa la función to_categorical de la biblioteca Keras.
y_train = to_categorical(y_train, 10) convierte las etiquetas de entrenamiento en datos categóricos con 10 clases.
y_test = to_categorical(y_test, 10) convierte las etiquetas de prueba en datos categóricos con 10 clases.

A continuación, definiremos la arquitectura de la CNN.

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Define the model architecture
model = Sequential()

# Add convolutional layers
model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# Flatten the output of the convolutional layers
model.add(Flatten())

# Add fully connected layers
model.add(Dense(512, activation='relu'))
model.add(Dense(10, activation='softmax'))

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Desglose del código:

from keras.models import Sequential importa la clase Sequential de la biblioteca Keras.
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense importa las clases Conv2D, MaxPooling2D, Flatten y Dense de la biblioteca Keras.
model = Sequential() crea un nuevo modelo Sequential.
model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3))) agrega una capa convolucional con 32 filtros, un kernel de 3x3, una función de activación ReLU y relleno SAME al modelo.
model.add(Conv2D(32, (3, 3), activation='relu')) agrega una segunda capa convolucional con 32 filtros, un kernel de 3x3 y una función de activación ReLU al modelo.
model.add(MaxPooling2D(pool_size=(2, 2))) agrega una capa de max pooling con una ventana de 2x2 al modelo.
model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) agrega una tercera capa convolucional con 64 filtros, un kernel de 3x3, una función de activación ReLU y relleno SAME al modelo.
model.add(Conv2D(64, (3, 3), activation='relu')) agrega una cuarta capa convolucional con 64 filtros, un kernel de 3x3 y una función de activación ReLU al modelo.
model.add(MaxPooling2D(pool_size=(2, 2))) agrega una segunda capa de max pooling con una ventana de 2x2 al modelo.
model.add(Flatten()) aplana la salida de las capas anteriores en un vector 1D.
model.add(Dense(512, activation='relu')) agrega una capa densa con 512 neuronas y una función de activación ReLU al modelo.
model.add(Dense(10, activation='softmax')) agrega una capa densa con 10 neuronas y una función de activación softmax al modelo.

Finalmente, entrenaremos la CNN en los datos de entrenamiento y evaluaremos su rendimiento en los datos de prueba.

# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model
model.fit(X_train, y_train, batch_size=32, epochs=10, validation_data=(X_test, y_test))

# Evaluate the model on the test data
score = model.evaluate(X_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Desglose del código:

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) compila el modelo utilizando la función de pérdida de entropía categórica, el optimizador Adam y la métrica de precisión.
model.fit(X_train, y_train, batch_size=32, epochs=10, validation_data=(X_test, y_test)) entrena el modelo en el conjunto de datos de entrenamiento con un tamaño de lote de 32 durante 10 épocas. El conjunto de datos de validación se utiliza para evaluar el modelo durante el entrenamiento.
score = model.evaluate(X_test, y_test, verbose=0) evalúa el modelo en el conjunto de datos de prueba sin imprimir ninguna salida.
print('Test loss:', score[0]) imprime la pérdida del modelo en el conjunto de datos de prueba.
print('Test accuracy:', score[1]) imprime la precisión del modelo en el conjunto de datos de prueba.

Este proyecto proporciona una aplicación práctica del aprendizaje profundo en el campo de la clasificación de imágenes. Demuestra cómo utilizar CNN para clasificar imágenes del conjunto de datos CIFAR-10. El código proporcionado puede servir como punto de partida para una exploración y experimentación adicionales.

Conclusión del Capítulo 13

En este capítulo, emprendimos un viaje a través de tres proyectos prácticos de aprendizaje automático, cada uno ilustrando la aplicación de diferentes técnicas de aprendizaje automático. Nuestro viaje comenzó con un problema de regresión en el que pronosticamos los precios de las viviendas, una tarea común en la industria inmobiliaria. Luego, nos trasladamos a un problema clásico de clasificación de texto, el análisis de sentimientos, utilizando el algoritmo de Naive Bayes. Por último, nos aventuramos en el mundo del aprendizaje profundo con un proyecto de clasificación de imágenes utilizando Redes Neuronales Convolucionales (CNN).

Cada proyecto estuvo acompañado de código Python, lo que proporciona un enfoque práctico para comprender estos conceptos. Estos proyectos no solo sirven como demostración de las técnicas discutidas en los capítulos anteriores, sino que también proporcionan una base para el desarrollo de modelos de aprendizaje automático más complejos.

A medida que avanzamos, recuerda que la clave para dominar el aprendizaje automático es la práctica y la experimentación. No dudes en modificar el código, probar diferentes algoritmos, ajustar los parámetros y ver cómo estos cambios afectan el rendimiento del modelo.

Este capítulo ha sido un testimonio del poder y la versatilidad del aprendizaje automático. Ya sea para predecir los precios de las viviendas, analizar sentimientos o clasificar imágenes, el aprendizaje automático tiene una amplia gama de aplicaciones. Esperamos que estos proyectos te hayan inspirado a explorar más y a crear tus propios proyectos de aprendizaje automático.