Cómo 3 proyectos de ciencia de datos personales me ayudaron a conseguir 5 entrevistas de trabajo

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 plt

acc = 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.


Comentarios

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *