En un mundo donde las imágenes juegan un papel importante, los proyectos de clasificación de imágenes son una forma fantástica de demostrar su competencia en el aprendizaje profundo y la visión por computadora.
Al crear un modelo sólido de clasificación de imágenes, puede mostrar su capacidad para analizar y extraer información significativa de los datos visuales.
Primero, descarguemos el conjunto de datos y extraigamos:
!wget https://www.dropbox.com/s/6s72bm2vuvmyx6y/cats_and_dogs.zip
!unzip cats_and_dogs.zip
A continuación, necesitamos dividir el conjunto de datos en conjuntos de entrenamiento y prueba:
import os
import shutil# Create directories for training and testing sets
os.mkdir('train')
os.mkdir('test')
# Copy the first 10,000 cat images to the training set
cat_files = os.listdir('cats_and_dogs/train/cats')
for file_name in cat_files[:10000]:
shutil.copy(f'cats_and_dogs/train/cats/{file_name}', 'train')
# Copy the first 10,000 dog images to the training set
dog_files = os.listdir('cats_and_dogs/train/dogs')
for file_name in dog_files[:10000]:
shutil.copy(f'cats_and_dogs/train/dogs/{file_name}', 'train')
# Copy the next 2,500 cat images to the testing set
for file_name in cat_files[10000:12500]:
shutil.copy(f'cats_and_dogs/train/cats/{file_name}', 'test')
# Copy the next 2,500 dog images to the testing set
for file_name in dog_files[10000:12500]:
shutil.copy(f'cats_and_dogs/train/dogs/{file_name}', 'test')
Construyendo el modelo
Ahora que hemos preparado los datos, podemos comenzar a construir el modelo.
Usaremos una red neuronal convolucional (CNN) para clasificar las imágenes.
Primero, importemos los módulos requeridos:
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
A continuación, definamos la arquitectura CNN:
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(128, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])
Esta CNN consta de tres capas convolucionales seguidas de capas de agrupación máxima, una capa plana y dos capas densas.
La capa de salida usa una función de activación sigmoidea porque queremos clasificar las imágenes en dos clases (gatos y perros).
A continuación, compilemos el modelo:
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
Usaremos el optimizador de Adam y la función de pérdida de entropía cruzada binaria.
Aumento de datos
Antes de entrenar el modelo, realizaremos un aumento de datos para aumentar el tamaño del conjunto de entrenamiento y ayudar a prevenir el sobreajuste.
El aumento de datos implica la aplicación aleatoria de transformaciones como la rotación, el zoom y el volteo de las imágenes.
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
test_datagen = ImageDataGenerator(rescale=1./255)
Usaremos el ImageDataGenerator clase para realizar el aumento de datos. Establecimos rescale=1./255 para normalizar los valores de píxel al rango [0, 1]. También establecemos varios parámetros para realizar transformaciones aleatorias en las imágenes.
Entrenando al modelo
Ahora podemos entrenar el modelo:
train_generator = train_datagen.flow_from_directory(
'train',
target_size=(150, 150),
batch_size=32,
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
'test',
target_size=(150, 150),
batch_size=32,
class_mode='binary')
history = model.fit_generator(
train_generator,
steps_per_epoch=2000,
epochs=50,
validation_data=validation_generator,
validation_steps=500)
usamos el flow_from_directory método para generar lotes de imágenes aumentadas de los directorios de entrenamiento y prueba. Establecimos target_size=(150, 150) para cambiar el tamaño de las imágenes a 150×150 píxeles. también establecemos class_mode='binary' porque tenemos solo dos clases (gatos y perros).
Entonces usamos el fit_generator método para entrenar el modelo. Establecimos steps_per_epoch=2000 para especificar el número de lotes por época. también establecemos epochs=50 para entrenar el modelo durante 50 épocas.
Evaluación del modelo
Después de entrenar el modelo, podemos evaluar su desempeño en el conjunto de prueba:
model.evaluate(validation_generator)
También podemos trazar las curvas de precisión y pérdida:
import matplotlib.pyplot as pltacc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'b', label='Training accuracy')
plt.plot(epochs, val_acc, 'r', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
Construir un modelo de clasificación de imágenes con TensorFlow fue una experiencia emocionante y gratificante.
Con la ayuda del conjunto de datos Cats and Dogs, pude entrenar una CNN que puede clasificar con precisión las imágenes de gatos y perros.
Obtuve una sólida comprensión de los conceptos básicos de la clasificación de imágenes y el aprendizaje profundo, incluida la preparación de datos, la construcción de una arquitectura CNN, el aumento de datos y la capacitación y evaluación de modelos.